75746207
submission
MassDosage writes:
If you are familiar with the “Effective” style of books then you probably already know how this book is structured. If not here’s a quick primer: the book consists of a number of small sections each of which focus on a specific problem, issue or idea and these are discussed in a “here’s the best way to do X” manner. These sections are grouped into related chapters but can be read in pretty much any order and generally don’t depend on each other (and when they do this will be called out in the text). The idea is that you can read the book from cover to cover if you want but you can also just dip in and out and read only the sections that are of interest to you. This also means that you can use the book as a reference in future when you inevitably forget the details or want to double check something.
Effective Python stays true to this ethos and delivers 59 (not 60, nope, not 55) but 59 specific ways to write better Python. These are logically grouped into chapters covering broader conceptual topics like “Pythonic thinking”, general technical features like “Concurrency and parallelism” as well as nitty gritty language details like “Meta classes and attributes”. The range of topics is excellent and cover relevant aspects of the language that I’d imagine pretty much any developer will encounter at some point while developing Python programs. Even though there is no required order to reading the various sections if you want to read the book from cover to cover it’s organised in such a way that you can do this. It starts off with getting your head around coding in Python before moving on to specifics of the language and then ending with advice on collaboration and setting up and running Python programs in production environments.
I really enjoyed the author’s approach to each of the topics covered. He explains each item in a very thorough and considered manner with plenty of detail but manages to do this while still being clear and concise. Where relevant he describes multiple ways of achieving a goal while contrasting the pros and cons of various alternative solutions, ending off with what he considers the preferred approach. The reader can then make up their own mind based on the various options which applies best in a given situation instead of just being given one solution. The author clearly understand the internals of the Python language and the philosophy behind some of the design decisions that have resulted in certain features. This means that instead of just offering a solution he also gives you the context and reasoning behind things which I found made it a lot easier to understand. The discussions and reasoning feel balanced and informed by the experience of a developer who has been doing this “in the trenches” for years as opposed to someone in an ivory tower issuing dictats which sound good in theory but don’t actually work in the real world. The vast majority of the topics are illustrated through code samples which are built on and modified at each stage along the way to a final solution. This gives the reader something practical they can take away and use and experiment with and clearly shows how something is done. The code samples are easily comprehensible with just enough code to demonstrate a point but not so much that you get distracted by unnecessary additions.
While most of the topics are Python specific plenty of the best practices and advice apply equally well to other programming languages. For example in one section the author recommends resisting some of the brevity offered by the Python where this can lead to unreadable code that is hard to understand but the same could be said of writing code in many other languages (I’m looking at you, Perl). This also applies to a section related to choosing the best data structure for the problem at hand — if you end up nesting Maps within Maps in your code then you’re probably doing something wrong regardless of the language. Still, the main focus here is Python and the author does not shy away from going deep into technical details so you’ll definitely need some knowledge of the language and ideally some experience using it in order to get the most out of it.
Effective Python is not a book for complete newbies to Python and I think it’s suited more to intermediate users of the language wanting to take their skills to the next level or advanced programmers who might need some fresh takes on the way they do things. The subjects and opinions in this book could either convince you to do something differently or reassure you of the reasons why you’re already doing things a certain way (external affirmation that you’re right is also useful at times!) I’m no Python expert but I found the book drew me in and kept my attention and I certainly learnt a lot which will come in handy the next time I put on my Pythonista hat and do some Python coding. Highly recommended.
Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
70717567
submission
MassDosage writes:
Lauren Ipsum (A Story About Computer Science and Other Improbable Things) Book Review by Mass Dosage
As the full title to Lauren Ipsum (A story about Computer Science and Other Improbable Things) indicates, this is a book about Computer Science but what’s surprising about it is that it manages to be about Computer Science without actually ever directly referring to the subject or even to computers at all. It is in fact a fictional story about a young girl called Lauren who gets lost after wandering into a forest near her house after an argument with her mother. She stumbles into a world populated with all kinds of strange creatures and colourful characters some of whom she befriends in order to figure out how to get back to her home. The “figuring out” part of the plot is where things get interesting as she has many attempts at solving this problem with different characters giving her often contradictory advice and Lauren then has to decide what exactly she’s trying to do and which of the various possible solutions is the best. This involves a fair amount of trial and error, learning from certain mistakes and trying different approaches. If this is starting to sound familiar to those who have written software then that’s the whole point. Lauren Ipsum is cunningly littered with references to Computer Science and in particular to things like algorithms, logic puzzles and many other of the theoretical underpinnings of the subject.
In the course of her adventures Lauren encounters characters like Xor the chameleon, Hugh Rustic the shop owner, a flock of round Robins and a Wandering Salesman. Anyone who knows a bit about computer science will be aware of the topics that are being alluded to here. This is also evident in some of the places she visits — a forest made up of red and black trees, the Island of Byzantium and a Garden of Forking Paths. All these insider references are obviously more enjoyable if you know the subject but it doesn’t really matter if you don’t get them as the story itself is separate from all the in-jokes. It’s also almost certainly the intention of the authors to stimulate people to look up some of the things they refer to and thus learn more about computer science. Lauren Ipsum can thus be read on two levels — one as a straightforward adventure story and the other as a “find and research the hidden references” book. The title of the book is itself a play on words of “Lorem Ipsum” which I’ll leave you to read up on on your own.
The chapter I enjoyed the most was one that covered building up a solution to a problem by breaking it down into smaller pieces and then combining these to come up with the final answer. In the book Lauren first learns how to draw a line and then that she can then draw and connect four of these to make a square. Even better is the discussion of the seemingly simple task of how to draw a circle which demonstrates that there are different ways of doing this, each having their own pros and cons. The solutions can be easily described as a set of steps and the question of how to control the size of the circle can be specified separately from the steps themselves. This is done without referring to any of the technical terms directly (one of the first chapters in the book is all about avoiding jargon) however what is actually being described will be instantly recognisable to anyone who has written some code — namely algorithms,algorithmic complexity, variables and parameter passing. This is quite a different way of illustrating programming concepts instead of the usual manner which involves lots of theory and code examples. Lauren Ipsum’s approach offers a much lower learning curve with simple story driven metaphors that can then be applied practically later.
The target audience of the book is probably children from around the age of 8 and up with the intention being to spark an interest in computers without the intimidation and possible connotations of boredom that a textbook might evoke. The story is entertaining but relatively simple and most of the more serious subject matter is just touched on in passing. There is an Appendix at the end which covers a few of the topics in more technical and mathematical detail but there is plenty that isn’t covered and it is up to the reader whether they want to find out more in their own way.
I found Lauren Ipsum an entertaining read, even though some of the computer science references are a bit forced. I ended up looking up a few things I wasn’t entirely sure about and learnt something new in the process and I can imagine this being even more the case for someone new to the subject. Even if the reader isn’t an aspiring geek-to-be there should be enough in the story here for them to enjoy and maybe help convince them that Computer Science can actually be fun or at the very least give them a taste for why problem solving is interesting and useful.
Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
68072745
submission
MassDosage writes:
At the the risk of exposing my age I remember building my first website using a rudimentary Unix text editor (Joe) and carefully handcrafting the Hypertext Markup Language (HTML) while directly logged on to the web server it was being served from. Back then Cascading Style Sheets (CSS) weren’t even a glint in the eyes of their creators. A lot has changed and there’s now a world of fancy WYSIWYG web page editors to choose from as well as Content Management Systems that allow you to create websites without looking at the underlying code at all. While this is all very useful and allows less technical people to create websites I still feel that having at least some knowledge of how everything works under the hood is empowering — especially in situations where you want to go beyond the limits placed on you by a certain tool. This is where Build your own website (A comic guide to HTML, CSS and Wordpress) comes into the picture. Its aim is to enable people new to web development to learn the subject by teaching the fundamentals of HTML and CSS first and only then describing how to use a Content Management System (CMS) — in this case Wordpress. While Wordpress might not be everyone’s kettle of fish it’s a good choice as an example of a modern CMS that is easily accessible and very popular. The concepts presented are simple enough that it should be easy enough for a reader to apply them to a different CMS should they want to.
To be clear, this book is intended for people who have little to no experience building websites and it is appropriately written in a non-formal, fun and non-threatening manner. Each chapter has the same format where a topic is initially covered at a high level in the form of a cartoon that is really easy to grasp. This is then followed by a more in-depth repetition of the same content using more “traditional” text and diagrams. Most chapters then end with a summary of the key points which can be used as a simple reference. This layout means that if you’re a quick learner or are familiar with some of the concepts you can just read the comic section and then try implementing the material covered on your own. On the other hand if you want more information and depth you can read the text that follows.The material is presented in such a way that it should be easy for the reader to “learn by doing” as they copy or modify what the main character in the cartoon does (in this case building a website for her photography portfolio). All that’s needed to get started is a browser, a text editor and some knowledge of how to organise files on a file system. This coverage of raw HTML and CSS may sound off-putting to non-technical people but it’s presented in such a simple manner that pretty much anyone should be able to follow along. The benefit of this “back to the basics” approach is that one is not limited to using only a certain piece of software and instead the fundamentals can be applied to other tools later.
The book provides a good introduction to HTML and describes some useful tags that can be used to start creating a simple website. CSS are explained in a similar manner and the reader is shown how they can be used to easily change the look of a website. These two technologies are the bedrock on top of which pretty much all web development rests and thus understanding them is a prerequisite for anyone wanting to create their own websites. The book also does a good job of showing how a content management system like Wordpress builds on top of these foundations and how you can still get to the underlying HTML and CSS should you want to (as well as why this might be useful if you want to modify something that Wordpress does or doesn’t do). On the Wordpress front the basics are covered — from creating pages and page hierarchies to how these can be categorised and grouped. Unfortunately when going into more detail on this topic things lose a bit of coherence. Wordpress is obviously a big beast which has entire books devoted to it and cramming in a summary of it means having to leave out a lot. It seems as if the author might have had to trim these sections down and this has resulted in the text feeling a bit rushed and confusing which is in contrast with the rest of the book where the topics are covered in a slower and more detailed manner. Any book that describes using a piece of software like Wordpress to the level of explaining how to point and click one’s way through certain step risks becoming outdated as the software changes in future. For the most part this shouldn’t be too much of an issue as Wordpress isn’t covered in too much detail but it does mean that this book probably won’t be a reference you still use in five year’s time.
On the whole Build your own website succeeds in its goal of presenting a gentle learning curve and guiding people through what is needed to create a website from scratch. It is just technical enough that readers should be able to understand the fundamentals of what they are doing while being non-intimidating and introducing concepts at a relaxed and fun pace via the comic format. By the end of this book readers should have a solid grasp of the basics of website creation and be able to set up a simple site themselves, either by coding this up in HTML and CSS directly or by using Wordpress. For anything more advanced one would need to move on to other books or self-teaching but this book is a great starting point if you’re new to the subject.
Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
39731101
submission
MassDosage writes:
In a remarkable show of good timing Presentation Patterns turned up on my desk for review within days of me having been asked to give a presentation at a large tech conference. So I decided to read the book as I worked on my presentation and apply any lessons learned as I worked my way through it. The word “patterns” in the book’s title will be known to most software developers as a reference to the seminal “Gang of four” software design patterns book which codified common solutions to software problems. The concept of patterns originated in building architecture with the idea being that by categorising and naming solutions to problems, a common vocabulary could be built up that allowed practitioners in a certain field to communicate more effectively. This was hugely successful and has spawned the idea of looking for patterns in many other areas which is where this book comes in.
Presentation Patterns aims to apply patterns to the task of creating and delivering presentations and for the most part it succeeds. The format of the book is slightly biased towards those in the software industry as the authors all have software backgrounds. However after reading the introduction which explains the rationale behind patterns in general, as well as the specifics of how they are covered, this book should be useful to anyone interested in improving their presentation skills. The book is divided into chapters which follow the timeline of creating a presentation — starting with patterns on preparing a presentation (e.g. “Know your audience” and “Narrative Arc) through to actually building a presentation (e.g. “Defy defaults” and “Infodeck”) and ending with patterns related to the final delivery of the presentation (e.g. “Seeding satisfaction” and “Breathing room”). This temporal categorisation of patterns is logical and worked very well for me as I could read through a section and apply it to the part of the presentation I was working on at the time before moving on to the next section.
Each pattern is described using a standard format which includes: other names for the pattern; a definition of the pattern; a motivation for why it is relevant; a discussion of where it is applicable as well as the consequences of using it; and a list of related patterns. Because each individual pattern is described in the same way it’s easy to compare them and see why and how they should be applied. While patterns give advice on things that one should do, just as important is advice on what not not to do. The authors include plenty of this in the form of “antipatterns” which are described in the same way as patterns, the only difference being that they are things to avoid in a presentation, some examples being “Ant fonts” and “Disowning your topic”.
Scattered throughout the book are anecdotes from the authors that describe real world situations where certain patterns were useful and some additional back stories to how they were discovered or applied. These add some welcome variety to the text while also showing that this isn’t pure theory but has been derived out of the actual experiences of the authors (all of whom are regulars on the presentations circuit). Presentation Patterns can be read from beginning to end but after an initial read it will probably be even more useful as a reference — particularly by those who present regularly as they can look up information on a specific pattern that is of interest at a particular time.
While a lot of the patterns and antipatterns covered are fairly general and not tied to any particular technology, the authors do assume that most presentations will be created and delivered in a digital format. They try to avoid discussing any specific presentation software but in a few cases they go into more depth and describe how a certain technique would be implemented using Microsoft’s Power Point and Apple’s Keynote software. I’m a Libre Office user but fortunately most of their descriptions were easy enough to translate to another tool . Having said that, these cases are not the norm and if you are looking for a tutorial or manual on how to build presentations using a certain piece of presentation software then this book is not for you. I got the feeling that the authors were aiming for their advice to be timeless and have tried to describe generalities rather than the specifics of a particular tool.
Presentation Patterns is well written and contains lots of good advice, backed up by concrete examples from the authors’ past experiences. A wide variety of patterns are covered
and the breadth and the depth of these mean that there should be something relevant for most possible usages. Not every pattern is applicable to every type of presentation so it is up to the reader to understand when and where to apply specific patterns. For example, if your presentation is primarily going to be delivered by e-mail and read by people as opposed to you presenting it in person then certain patterns make more sense than others. The patterns are cross-referenced against each other so you can see how using one might influence the use of another. This is slightly annoying at the beginning when you are not familiar with all of them but as you expand your pattern vocabulary it starts to make a lot more sense.
I finished reading this book at around the same time I completed and then delivered my presentation and I definitely learnt some lessons that, when applied, made my presentation better than it would have been without them. At the end of the day most of the content is common sense and probably won’t be that surprising to anyone who has given or viewed presentations in the past but it is still useful to have it all written down in one place. I will definitely use the book again, probably not to read it from cover to cover but more as a checklist and refresher of what to aim for and what to avoid when I work on my next presentation. The patterns format might not be for everyone and will take a bit of getting used to by those for whom it is new but on the whole I think it works very well for this material and would recommend it to anyone hoping to improve how they prepare, create, build and deliver presentations.
Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
37760637
submission
MassDosage writes:
Wonderful Life with the Elements Book Review By Mass Dosage
I’ve always found Chemistry interesting, particularly in high school when I had the good fortune of having a Chemistry teacher who was not only really good looking, but a great teacher too. I studied it for a year at University and then moved on and haven’t really given the periodic table and its elements much thought since. This changed when the Wonderful Life with the Elements was delivered to me two weeks ago. It’s one of those books that aims to make science fun and, unlike many other attempts which turn out to be pretty lame, this actually succeeds in presenting the periodic table in a fresh, original and interesting manner.
Wonderful Life with the Elements is the brainchild of a Japanese artist, Bunpei Yorifuji, who has published a few other books in Japan and created some adverts for the Tokyo metro (which you can find by doing an image search for his name and “Do it at home”). His animation style for these adverts features simple, clean cartoon characters drawn in yellow, black and white. In a Wonderful Life with the Elements he has taken this technique and applied it to the periodic table by drawing each element as a cartoon character where every detail has some scientific significance. Elements that were discovered a long time ago have beards while more recent discoveries have dummies (pacifiers for those in America) in their mouths. Heavy elements are fat. Elements with lots of industrial uses wear suits while those that are man-made look like robots. He also adds amusing little touches to each element and it is obvious he took a lot of time and care in doing this and researching and then presenting the details about each of them. It really feels like the elements have individual personalities which is quite an achievement for what is often presented as rather boring and dry subject matter.
This book isn’t merely a collection of cartoon drawings — information is also included covering when and how the elements were discovered, what they are (or were) used for and other interesting or amusing pieces of trivia. There are also the more traditional facts like atomic number, symbol, position in the periodic table, melting and boiling points and density. Some elements get more detail than others depending on how well known and/or useful they are. My only real criticism of the book is that the elements in period 7 only get small drawings and a cursory description each. I’m not sure why they were singled out for this treatment. Did the author get bored towards the end? Was there lack of budget? Did he run out of time? Does he have a personal grudge against period 7? Considering that this period includes rather famous elements such as Uranium and Plutonium and that they get the same low level of detail as relative unknowns like Ununseptium and Darmstadtium this feels like a rather odd omission.
The main stars of the Wonderful Life with the Elements are the elements themselves but the introductory and closing chapters are worth reading too. The book starts off with an overview of the elements and which ones are found most commonly on our planet and in our living rooms before moving on to the periodic table itself and an explanation of what the various details on the cartoon drawings of the elements mean. The closing sections describe which elements are an important part of a human diet and what the effects of eating too little or too much of each of them are before wrapping up with a warning about the possibility of us running out of certain elements and what the negative impact of this could be. This is all written in an informal, humorous style that makes all these facts appear really interesting and, dare I say it, fun to read.
Wonderful Life with the Elements is a very enjoyable book and the author has done a great job of injecting some colour and personality into what many people would view as a rather dull topic. If I had had a book like this in high-school I think I would have found Chemistry interesting, even without the attractive teacher. It is worth pointing out that is isn’t a replacement for a Chemistry text book — it only touches the surface of the large body of theory that underpins the elements and the periodic table. However I would still wholeheartedly recommend this to anyone with even just a casual interest in the subject. The original presentation of this material and the amusing personal touches are fantastic and turn this book into a fun, easy read which isn’t something one can say about most books that deal with Chemistry.
Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
36868585
submission
MassDosage writes:
After nearly 15 years or of writing code professionally it was refreshing to take a figurative step back and read a book aimed at people getting started with computer programming. As the title suggests, Think Like A Programmer tries to get to the core of the special way that good programmers think and how, when faced with large and complex problems, they successfully churn out software to solve these challenges in elegant and creative ways. The author has taught computer science for about as long as I’ve been programming and this shows in his writing. He has clearly seen a lot of different people progress from newbie programmers to craftsmen (and craftswomen) and has managed to distil a lot of what makes this possible in what is a clear, well-written and insightful book.
Think Like A Programmer is probably best read by those with at least a year’s experience with programming, such as first or second year computer science students or those picking up programming on their own. The code examples in the book are all written in C++ so a basic knowledge of C++ syntax is required but this should be easy to pick up by anyone with familiarity with related or similar languages. Experienced programmers looking to brush up on their fundamentals will most likely find something useful here too. They probably do a lot of what is suggested here already without being aware of it but it can be encouraging to see this formalised in a book. I found it gratifying to see that some of the techniques I use daily were covered here — it’s good to know that I’m not the only one who scrawls down funny diagrams and sketches out a rough plan before actually typing any code.
Different types of problem solving are discussed in separate chapters which cover the use of data structures, pointers, recursion and code libraries before wrapping up with a final chapter that brings all the previous approaches together. The book is intended to be read in its entirety with later chapters making frequent references to topics covered earlier. Think Like A Programmer is not a cheat sheet or cook book with quick fixes but a more substantive book that rewards those who read it as thoroughly as it has been written. Each chapter contains a few examples which are used to explain the topic under discussion and these have been well chosen to illustrate the key concepts. A series of exercises are also included which build on and extend each chapter. The author stresses that if the reader really wants to learn something and improve their problem solving skills then these exercises should be considered even more important than the text. The best way to learn how to program is by doing and the exercises force one to put what one has just learned into practise. The first few exercises at the end of a chapter are relatively simple and are basically variations on the examples that help the reader build confidence before moving into more challenging and tricky exercises that push one to apply one’s recently acquired knowledge to new limits.
Throughout the book everything is explained in a good level of detail and enough background information is provided so that the reader should never feel out of their depth. The pros and cons of the various presented solutions are clearly weighed up with logical backing. The author is obviously very knowledgeable and experienced with teaching hard concepts to new learners and this shows in his no-nonsense, down-to-earth but enjoyable writing style. The code samples are clear and well thought out as are the diagrams that accompany the various examples. The chapter on classes was the only one where I felt like focus was being lost due to too many C++ implementation details but perhaps that’s just the nature of the language. I would have liked the example here to show more clearly how classes can turn a morass of functional code into something more logically grouped and easier to understand. To be fair, the exercises at the end of this chapter do ask one to do this by asking one to convert a collection of string utility functions into a more logically organised string class. This again shows the importance of actually doing the exercises and not just simply reading them.
The core idea of how programmers take a complex problem and then break this down into smaller, more manageable and solvable parts is well described. The importance of having a plan before jumping in and writing code without thinking is stressed and there are great suggestions for how to take stock of your own personal strengths and weaknesses and come up with a personal plan that works for you. The example is given of someone who likes jumping right into coding — for someone like this it probably makes sense for them to do early prototyping as a way to start solving a particular problem, as long as the longer term plan involves taking a step away from this and incorporating the lessons learned into a more thoroughly thought out solution later. In this, as in the rest of the book, the author shows his years of experience teaching a wide range of people with different skill sets and approaches to problem solving. There is no single way to think like a programmer, but rather a number of tried and tested strategies that can be employed in various ways. Think Like A Programmer captures this core idea in an satisfying, down to earth manner and I can highly recommend it to anyone wanting to improve their problem solving capabilities. I wish I had had this book when I started studying computer science — the fundamentals contained here would have been a valued addition to the text books teaching syntax and specific technologies.
Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
22562864
submission
MassDosage writes:
Getting Started with Audacity 1.3 by Bethany Hiitola covers the basics of using the Audacity software package for recording and editing audio. This book is written in a tutorial style and stays true to its title by covering Audacity from a newcomer's perspective with lots of diagrams and detailed explanations of how to install and setup Audacity and use its most essential features. This is all very much aimed at people who are new to audio software and are looking for a simple way to get started and be guided through creating and editing an audio recording. On the whole it achieves this but is occasionally let down by overly simplistic content and shoddy editing.
Audacity 1.3 is the latest version of this well known free and open source software program that runs on GNU/Linux, Windows, Macs and any other operating system that an aspiring techy gets the source code to compile on. The author has done a good job of keeping the software's cross-platform nature in mind by minimising anything operating system specific and describing alternative approaches where necessary. I followed along with the book's examples using Linux and didn't run into any platform-specific issues.
I've personally had a fair amount of experience with many different audio editors over the years but haven't worked that much with Audacity so I was interested in what this book had to offer me. To be honest most of what is covered I had already figured out myself just from playing with Audacity in the past. This book is really targeted at complete newbies — if you've used an audio editor of any form in the past and are comfortable recording or importing audio and applying some basic filters and effects to it, then the very basic, tutorial nature of this book probably won't be of much interest to you. However, for those who don't know much about audio editing and are looking for somewhere to start then this might just be what you're looking for.
It may not be the prettiest audio tool on the planet, but Audacity really is "good enough" for those wanting to do simple editing. The fact that it is totally open and free for anyone to download and use means that the software itself is a great starting point for an aspiring audio editor or creator as the barriers to entry are very low. The first few chapters of the book take one through installing Audacity and explaining how the program works and how its user interface is laid out. The minimal equipment needed to make a vocal recording (i.e. a microphone, soundcard and headphones) is touched on and again it is very clear that there is a low barrier to creating something simple. If you want to make state of the art recordings then you may need to spend a fortune on equipment but for the purposes of getting started one really doesn't need much.
The main example in the book covers creating a podcast from scratch which is a good choice as its something that many casual users are probably interested in. This also provides an opportunity to discuss most of the important aspects of recording audio and doing common tasks like removing noise, splitting up tracks, adding background music, fading sound in and out and applying various effects.This is all done with lots of diagrams and step-by-step explanations of the menu items and buttons to push to achieve this. Strangely enough the author mentions keyboard shortcuts (which is good) but instead of describing probably the most useful shortcut of all (CTRL-S to save) she describes going to the file menu and selecting "Save" each time.
The podcast example is expanded upon to show how audio can be cut, pasted, silenced and made louder or quieter. Noise removal is covered in a bit more depth than the other topics which is a good thing as the filter that is used to do this isn't very user friendly — after selecting the noise profile it vanishes with no information on what to do next. This is also something most users will probably need at some point as are the steps on how to normalise and compress the audio. The effects and filters covered are also the ones that a new user is most likely to want to start playing with. The bare essentials are wrapped up in a chapter explaining how to export audio to MP3 (or other formats) and some suggestions are given as to how to make this publicly available via an RSS feed or by uploading the audio to iTunes. It would have been nice to have some pointers to alternative ways of doing this, especially some more open form of publishing than Apple's proprietary and closed platform. There is even a whole section on how to circumvent Apple's DRM by converting locked iTunes audio files to CD and then importing from there into Audacity which is probably useful to some but feels a bit out of place in a book about an open tool like this.
The book also covers a number of other topics which are assembled somewhat randomly but are generally useful. These include adding background music, time shifting, adjusting pitch and tempo as well as various options for aligning, splitting, joining and moving multiple tracks around. Every effect that ships with Audacity is covered and this is serves as a reference guide for what each of them does. Adding more functionality to Audacity via the use of plugins is touched on but this is really just a teaser and isn't covered in much depth (probably due to the platform-specific nature of their installation).
I was a bit disappointed in the book as I didn't learn as much as I would have liked, this is really more of a "how to do the basics" and doesn't provide much depth on Audacity or audio concepts in general. It would have been nice if the book had wrapped up with some pointers for those wanting to know more or go further with their audio editing skills. The overall tone of the book is friendly which suits its "for beginners" approach but at times it is let down by not sounding very authoritative or convincing. The bad grammar and silly typos that weren't caught by the editors don't help much in this regard either. Give it a go if you're the type of person who needs a tutorial guide to get started, otherwise you can probably figure out most of the topics covered by just playing with the software yourself.
21456292
submission
MassDosage writes:
Software Build Systems Review by Mass Dosage
Software Build Systems by Peter Smith is a well written, albeit rather lengthy book that covers the intricacies of systems used to build software. It tries to do this in a technology-neutral manner where possible but covers existing tools like Ant, Make and Scons as a means of illustrating the various concepts covered instead of just focusing on theory. The real world examples illustrate building Java, C/C++, C# and Python software and cover scaling up from small builds with tens of source files up to massive builds with tens of thousands. All of the technologies used are introduced in some depth which newcomers should find useful but experienced build developers may want to skim over.
Software Build Systems weighs in at a hefty 580 odd pages and covers a lot of ground. It is targeted at developers, managers and build engineers and while there is definitely something for all of these groups, each of them will most likely find themselves skipping sections which are either not of interest to them or are too basic. It is also important to note that this book is not a hands-on tutorial of how to set up a build system from scratch but instead uses a variety of detailed examples to illustrate its concepts with pointers to external documentation for those wanting to actually implement a complete build system of their own.
The book is clearly divided into parts which move from "The Basics" to "The Build Tools" and then on to "Advanced Topics" and finally "Scaling Up". "The Basics" really is basic and most build engineers and developers worth their salt can probably skim read most of this. The fundamentals of C/C++, Java and C# are also covered illustrating a major theme in this book in that it tries to be programming language neutral and just use the different languages as examples to explain various concepts. While this is an inclusive, worthwhile aim it does mean that someone only interested in say, building Java software, will find large parts of the book irrelevant. This applies particularly to the chapters on the various build tools where Make, Ant, SCons, CMake and Eclipse are all covered in painstaking detail. The pros and cons of each of these tools are discussed in a non-biased manner using real world examples where possible. Anyone who has actually written a build system using one of these tools probably won't find much they don't already know but for a manager or someone new to any of these technologies the author provides a a good introduction with mentions of similar tools and pointers for finding out more about each of them.
"Advanced Topics" is where things start to get interesting as concepts like dependency graphs, change detection and version management that the build tools rely on to function are discussed in depth. A lot of the advice in these chapters feels like it comes from practical experience and the best parts are where tool-neutral tips are provided. There is a bit too much detail here as well as the odd digression which feels unnecessary in a book of this length. Do we really need to know the details of lex and yacc in order to create a build system? The author clearly has an understanding of open source development and competently discusses the wild world of building software that may run on a plethora of machines and platforms that the developers have little or no control over as well as software that is built in a more clinical manner for a limited set of environments.
Build systems for massive software projects are covered in "Scaling Up" and the author acknowledges that this probably isn't relevant for everyone. I however think that the first chapter in this section ("Reducing complexity for end users") is the best in the whole book and applies to all build systems, regardless of size or technology. A better title for this chapter would have been "Best practices for build systems" as it doles out plenty of good tips such as how to automatically detect dependencies, what not to keep in a source control system, when to abort a build (early), why to ensure there is always a way to clean up all build-generated artefacts and so on. The gist here is to try to reduce complexity wherever possible and the advice is all very well reasoned and practical. The book wraps up by covering methods for reducing the size of a build and ways to speed up and optimise builds.
Overall this is a very well written, edited and structured book but it does suffer from attempting to cover too much and going into detail on topics which aren't going to be of interest to everyone. A prime example of this is the section on packaging technologies where I doubt that someone concerned with creating Debian packages will find the information on the Nullsoft Scriptable Install System very useful, or vice versa. The same applies to the varying levels of technical detail in the book — a manager may find the introductions to concepts like compiled versus scripted languages enlightening but to most developers this will be old hat. Conversely the intricacies of how Make calculates its dependency graph is probably interesting to a build engineer but most managers will be out of their depth.
This isn't the kind of book most people will read from cover to cover. Instead I recommend skimming through the sections that aren't immediately applicable and just focusing on the parts that discuss the particular build technologies the reader is interested in as well as the more technology neutral parts towards the end. It is obvious that years (if not decades) of real world experience have been distilled in Software Build Systems. It is just a shame that this process wasn't a bit more focused as this could have been a great book, instead of just a good book with some great sections and some sections that most readers will find themselves skimming over.
Full disclosure: I was given a copy of this book free of charge by the publisher for review purposes. They placed no restrictions on what I could say and left me to be as critical as I wanted so the above review is my own honest opinion.
