Book Review: “A Mind at Play”

A Mind At Play by Jimmy Soni and Rob Goodman should be on every techie’s gift list this year because it is superb and because everyone in a technology or information field should know who Claude Shannon is.

When Jimmy Soni offered me a review copy of this new biography of Claude Shannon, I immediately said yes. I knew a little about Shannon from reading The Idea Factory and The Information, and I was looking forward to learning more. The results in A Mind At Play are just what I hoped for.

Soni and Goodman do an excellent job of presenting Shannon’s technical work  to a mostly lay audience, although there is enough depth (and footnotes) to allow you to dig deeper if you are interested. The explanation of his information theory work is clearly laid out and builds from the simplifying model of how communication works to the stochastic analysis of letter frequency and redundancy to finally reach the description of the Shannon limit on the communication speed over any medium. They also cover his contributions in other fields like genetics and mathematics.

The technical sections are interspersed with anecdotes from his life, from his education through his career at Bell Labs and MIT, showing how his continual “constructive dissatisfaction” with the state of the world served as a motivating force in his exploration of a wide range of topics. He set his own course and focused on the things he wanted to, and was privileged to have the freedom to do so. While some of the topics seemed like play, his work always exposed something new; at least to him.

For more details, download this interview with the authors on the Software Engineering Daily podcast.

The Idea Factory

I just finished reading The Idea Factory by Jon Gertner. It’s a
history of Bell Labs and its impact on modern technology. I love these
sorts of books, that talk about engineers and scientists solving
problems and discovering how the world works. Gertner’s writing moves
along at a nice steady pace, and he tells the stories with a good
balance of scientific detail – not so much that you need a physics
degree, but enough that you understand the difficulty and significance
of the work.

Most of the book talks about a different era, when attitudes about
monopolies were different and pure research was funded with fewer
expectations of immediate profit. That model no longer works in our
modern competitive environment, and I am left wondering how we will
manage to make the next fundamental leap forward (and what that leap
will be) when most businesses can’t afford to take such a long view,
and most research universities struggle for funding.

I also want to know who the Jon Gertner, Tracy Kidder, or Scott
of OpenStack will be.

Book Review: Python Testing Cookbook

I received a review copy of Python Testing Cookbook by Greg
late last week. The timing was perfect, since we have been
talking a lot about increasing the amount of automation we use in our
testing at work. I scanned through the book quickly to get a sense for
whether I should give it to our QA team, and I liked what I found.

Quick Review

My review for the impatient reader:

Why I picked it up: The timing was perfect. We are applying more
test automation techniques as part of improving our QA process at
work, and I hoped to find some useful tools.

Why I finished it: It’s a fast read, especially when you skim over
the code. There are a lot of good tips, and it introduces a range of
tools, which is just what I needed.

I’d give it to: Our QA team. It will explain some of the tools the
development team is already using and introduce others that are well
suited for the needs of the QA team.


I’m not normally a fan of “cookbook” style technology books. The ones
I have read were disorganized grab-bags of random suggestions only
useful to someone with a background in the topic they covered. This
book is an exception. The author did a good job of organizing Python
Testing Cookbook
to avoid the grab-bag feeling. Each chapter
introduces a new concept, and the sections and recipes build on each
other in a steady progression. Because it introduces basic concepts
such as the unittest and doctest frameworks before moving to
test runners like nose and advanced tools such as mock,
Pycurracy, robotframework, lettuce, and Jenkins, the book
is useful for someone approaching test automation for the first time
who wants to read straight through, without sacrificing the
quick-reference goal of the cookbook format.

I’m not normally a fan of “cookbook” style technology books. This
book is an exception.

The book stands up well as a beginner- or intermediate-level text
because it takes the reader beyond a strict “how to” structure. In
addition to the step-by-step instructions you expect, each recipe
explains how the techniques employed work and gives advice about when
and why to use them. Some of the best tips in the book are included
in those sections.

I think our QA team will find the book especially helpful because it
covers more than green field development work. Chapter 9 in particular
talks about how to apply the techniques covered earlier with legacy
systems. Those tips encourage you to start testing, even if it is a
big project and you’re unlikely to reach 100% coverage in the

“Don’t get caught up in the purity of total isolation or worry about
obscure test methods. First thing, start testing.”

Chapter 4 covers a few interesting techniques and tools for “Behavior
Driven Development”. Lettuce piques my interest, as I hadn’t heard
of it before. The ability to describe tests independently of the code
that performs them will be useful for non-programmers (as long as they
have some help to bind the test descriptions to those checks, of

I only have two negative comments to make. Most or all of the program
output is presented as screen shots. While I’m sure that made their
editing process easier (there’s no need to worry about whether a copy
editor broke the output formatting or “corrected” the language in an
error message), the white-on-black images don’t come out well in the
printing. In a few cases is looks like the opacity for the terminal
window was not set high enough to mask the text from other
windows. It’s distracting, but the important text is clearly legible,
so in the end it isn’t a big problem.

The other point is related to scope. A few of the more advanced tools
(Jenkins and TeamCity), are introduced without a lot of depth. Basic
use patterns are presented to get you started, and reference links are
included for readers who want to find out more about the tools. I
think this is a limitation of the size and format of the book, rather
than an oversight, and so I can’t complain too much, but those
sections do stand out as thinner than the others.


I recommend this book. It exceeded my expectations (both of the
format, and of Packt’s reputation), and provides a clear introduction
to tools and techniques for testing your application from a variety of

Disclaimer: I received a free review copy of this book from the

Book Review: Masterminds of Programming

Quick Review

My review for the impatient reader:

Why I picked it up: It promised insight from a collection of
programming language inventors.

Why I finished it: Although there was less depth than I expected,
it was interesting to see how divergent the interviewees’ opinions are
on some topics.

I’d give it to: A serious programmer who has been working for a
few years and is ready to grow beyond the usual “how to” books and is
looking for a more contemplative book.


Masterminds of Programming is a collection of interviews with
“Creators of Major Programming Languages.” It is edited by Federico
Biancuzzi and Shane Warden, and was published by O’Reilly and
Associates in 2009. It is organized based on the language, with each
of the 17 chapters containing an interview with the creator, or
creators in some cases. It covers a wide variety of languages,
including compiled languages like C++ and Objective C, interpreted
languages like Python and Perl, and even UML.

Although it was interesting to learn a little about the backgrounds of
languages I had heard of but never used, it was more enlightening to
read about the broader topics the interviewees discussed. I found it
especially fascinating to see the conflicting opinions many of them
hold on some topics.

“Whenever I hear people boasting of millions of lines of code, I
know they have grievously misunderstood their problem. There are no
contemporary problems requiring millions of lines of code.” –
Chuck Moore, Forth

Although the questions are not the same in each interview, a few
common themes stand out. For example, opinions vary on the importance
of working on a team vs. individually. It is not entirely surprising
that the academics tended to favor individual work, or at least not
have extensive experience working on teams.

“The whole business of optimizing and coding is absolutely
wrong. You don’t do that. You optimize only if you have to and you
do it later. Higher level languages optimize computer time
automatically because you make fewer errors.” – Tom Kurtz, BASIC

The misguided use of object orientation is brought up several times,
and not just by designers of functional languages. Concurrency and
relationship with OOP and functional programming is also discussed in
a few places. There is a general consensus in the interviews that
concurrency is one of the important issues yet to be resolved in
computing, but there is little agreement about the solution.

There is more agreement on the need to keep languages, and programs,
simple. Several interviews include or refer to the quote from
Einstein, “Everything should be made as simple as possible, but no
simpler.” I also was surprised to see how many times older languages
such as Algol-60 and Simula were brought up as influences on more
“modern” languages, although perhaps I should not have been.


I recommend this book for serious programmers looking to move beyond
the usual “how to” books to find a more contemplative book. The
interviews have been put together with obvious care. They cover
similar topics without simply repeating the same question to each
participant. The result is easy to read, while still encouraging the
reader to go slowly and consider what is being said.

Book Review: Porting to Python 3

Lennart Regebro sent me a copy of his Porting to Python 3 following
PyCon 2011, and now that work on my own book is nearly complete I was
finally able to sit down and study it. I have two major Python 3
porting projects ahead of me soon, and I hoped that Lennart’s book
would guide those projects. I was not disappointed.

Quick Review

Inspired by Gene Ambaum and Bill Barnes’ review short-cuts, here’s my
review for the impatient reader:

Why I picked it up: I am preparing to port PyMOTW to Python 3
we are starting to study what it would take to make the switch at
work, too.

Why I finished it: At a computationally pleasing 128 pages, the
book gets right to the point, without a lot of fluff and filler.

I’d give it to: Developers with enough Python 2 code that porting
to version 3 is going to be a major project. Programmers who want to
support both 2 and 3 at the same time will also find helpful

Python 2 vs. 3

The Python community is in an interesting period of change. Major
development of Python 2 has stopped with release 2.7, but there are
still a lot of developers out in the world using it as their primary
tool. The number of packages available under Python 3 continues to
grow steadily, but there is still a lot of legacy code to be ported,
supported, or simply cut off. Lennart Regebro’s new book, Porting to
Python 3
, is a guide for those of us who have not yet completed our
transition. It covers the options for supporting Python 3, either
concurrently or exclusively, and includes guidance about choosing the
best approach for your project.

Just the Facts

While there is a lot to like about Porting to Python 3, the two
aspects that stand out are the size and the organization of the
content. The author does not beat around the bush or belabor his
point. His writing is clear and concise, resulting in a slim handbook
that can be given to a manager who needs to understand the
ramifications of moving from Python 2 to Python 3, while still
containing enough detail to be used by a developer for reference
during the porting process.

The author does not beat around the bush or belabor his point.

Strategies for Successful Migration

The material in the book is organized in exactly the way you need to
digest it. The first chapter is a quick explanation of what Python 3
is, with guidance for deciding when, and whether, to make the
switch. Chapter two covers strategies for migrating, either all at
once or during installation so that both Python 2 and 3 can be
supported with the same code base.

Next, the author helps you prepare for the porting effort by providing
tips for bringing your code into the best beginning state. He covers
the process for staging the migration by getting the code to run
correctly under Python 2.7, possibly with a compatibility layer so
that the same source can run under Python 3 as well.

The author helps you prepare by providing tips for bringing your
code into the best beginning state.

Chapter 4 introduces 2to3, the primary tool for automatically
porting Python 2 code to run under Python 3. 2to3 supports a large
number of conversions, but no automatic solution is going to be
perfect, so chapter 5 explains how to address the most commonly found
cases where the tool may have made the wrong decision or where it
could not translate the code at all.

Chapter 6 lists the cases where using more “modern idioms” will either
make the code easier to maintain for both Python 2 and 3, or make it
run more cleanly under Python 3.

Advanced Topics

The rest of the chapters are about more advanced topics, including
techniques for supporting Python 2 and 3 without using 2to3; changes
in the C API that affect extension modules; and customizing 2to3 to
handle cases that appear in your code, but are not common enough to
already be addressed by the core library.

Handy Reference

The appendices provide concise reference list of common porting issues
and their solutions, so it is not necessary to search the entire book
for a fix when you encounter a problem. There is also a list of the
standard library modules that have been renamed or otherwise
reorganized, something I will find especially useful while working on


Porting to Python 3 is self-published, and that shows in some of the
rough edges. But those do not detract from the value of the
information and advice that it contains. I recommend it for developers
preparing to migrate their code base, especially if there is enough
code to make it a major project. Programmers who want to support both
2 and 3 at the same time will also find helpful information.

Sample Chapter

The website for the book has chapter two, Migration
, available for free.

Disclaimer: I received a free review copy of this book from the

Book Review: Foundations of Python Network Programming

I received a review copy of Brandon Rhodes’ Foundations of Python
Network Programming
from Apress a few weeks ago, but had to wait to
read it until my own book was complete. I finished reading it this
weekend, and it was worth the wait.

Quick Review

Inspired by Gene Ambaum and Bill Barnes’ review short-cuts, this is
my review for the impatient reader.

Why I picked it up: I know Brandon through PyATL and was
confident that his years of experience would ensure that he put out a
high quality book. He more than met my expectations.

Why I finished it: The conversational tone made it easy to zip
through the sections covering material I was familiar with, saving
more time to study the rest more completely.

I’d give it to: Any Python programmer who wants a better
understanding of the fundamentals of network programming. Even an
experienced Python programmer will learn a few new tricks from the
sections covering more modern tools like ZeroMQ and paramiko.


This is the second edition of Foundations of Python Network
. The first edition by John Goerzen was released in 2004,
and while a lot has changed in the way we use computer networks since
then the fundamentals remain constant. Brandon Rhodes has improved the
second edition by cleaning up the old examples that are still
relevant, updating or replacing the ones that became obsolete, and
adding new material. The results benefit from Brandon’s high level of
expertise and depth of knowledge in networking.

The book covers a broad range of topics, and is organized so that each
section builds on the knowledge of the previous chapters. The
discussions move from from raw TCP and UDP to encryption with TSL, and
then on to application protocols like HTTP, SMTP, POP, IMAP, and ssh.
Each section explains not just how to do a task, but why doing it
that way works.

The examples in the book are clear and illustrate the concepts
described in the text. There are a few places where the exposition
would benefit from a diagram or two (especially in the description of
TCP message windows), but the explanation given does stand on its own.

Every chapter of Foundations of Python Network Programming is filled
with practical advice. After establishing the fundamentals of
networking in the first few chapters, the book goes on to cover
architectural issues that come up when creating client server
applications. The different uses for RPC and message queue
architectures are covered, as well binary versus text wire protocols.
The latter chapters, which cover higher level protocols, discuss
best-of-breed libraries, removing much of the guesswork for Python
programmers choosing tools for new projects.


I recommend Foundations of Python Network Programming for
programmers who want to move beyond the usual web framework-based
development paradigm to learn more about what is going on behind the
scenes. It is concise, but written in a conversational style that
makes it easy to read. After reading the book, you will have a good
grounding in the fundamentals of networking and be introduced to many
more complex subjects. Brandon includes a number of references to
other sources of more information, as well, for readers who want to go
beyond the fundamentals covered here.

Book Review: Practical Virtualization Solutions

Quick Review

My review for the impatient reader:

Why I picked it up: I have some basic knowledge of and experience
with VMware, but wanted learn more about Xen and Hyper-V.

Why I finished it: It reads quickly and provides a good grounding
in virtualization terms and technologies.

I’d give it to: Anyone looking into upgrading their infrastructure
using modern virtualization tools.


Practical Virtualization Solutions by Kenneth Hess and Amy Newman
covers a lot of ground. From basic introduction to the technology
itself, to advice about which of the big players to use now (and
to keep an eye on for the future), the authors walk you through all
the issues and potential gotchas of virtualization. Existing
virtualization users may find the early parts of the book a little
slow moving, but the advice in part 3 (“Hardware’s Role in
Virtualization”) looks at issues like I/O virtualization that most of
us haven’t seen before.

The most useful part of the book for me was chapter 2, which compared
the offerings from major virtualization vendors. The strengths and
weaknesses of the approach taken by each tool were explained, and the
authors give their advice, based on years of experience, about how to
decide which platform best fits your needs.

As part of the Negus Software Solutions Series, the book delivers
the promised hands-on experience in the remaining chapters of part 1,
where they give detailed procedures for setting up a virtual machine
and installing a guest operating system, using each tool in turn.
They go beyond the basic GUI instructions, too, as they dig into
implementation details like what the files in a virtual machine
definition contain. Each chapter ends with a real-world use case
showing how the tool helped an actual end-user.

Part 2 covers applications of virtualization for servers, desktops,
and network and storage resources. It is a good introduction to these
subjects, but not especially deep.

The third part of the book talks about hardware issues related to
virtualization. The authors emphasize the need to be realistic about
buying hardware to host your virtual servers, and include advice about
how to optimize your setup based on the hardware and software
compatibility between vendors.

They also discuss the tricky nature of network and I/O virtualization,
pointing out that adding more software to a part of the stack that is
already a bottleneck is unlikely to improve performance. They describe
the ways Vendors and OEMs are relying on hybrid solutions, with
special hardware and custom drivers, to obtain the best results.

Once you are convinced that virtualization is the right choice for
your setup, and you have done the work to select the appropriate tool,
you are ready for the planning advice in part 4. Beginning with tips
for justifying the move to a CTO or CFO, and then covering tools for
making the transition easier such as auto-discovery of services and
deployment automation, these final chapters reinforce and summarize
many of the tips from earlier chapters in the context of creating an
implementation plan.


I recommend this book for anyone considering getting into
virtualization who needs a comprehensive introduction. You’ll need
more detailed reference material once you select a tool, but
Practical Virtualization Solutions will give you the advice you need
to make that choice.

Disclaimer: I received a free review copy of this book from the
publisher as part of my participation in the CHUGALUG Book Club.

Book Review: Matplotlib for Python Developers

Matplotlib for Python Developers by Sandro Tosi is the latest in a
series of concise project-specific manuals from Packt. It covers
the matplotlib library for creating charts and graphs.

Quick Review

My review for the impatient reader:

Why I picked it up: I thought it might help with a project at work.

Why I finished it: I wanted to see what features matplotlib had
the could be useful, and how to integrate it with web frameworks.

I’d give it to: Anyone wishing to create custom charts and graphs,
especially pragmatically.


The book starts a little slowly, presenting lots of background
material and feature lists in chapter 1 without any real examples to
make them concrete. Chapter 1 also covers the installation process.
It’s a shame binary installers are required, and it isn’t clear
matplotlib and its dependencies work with tools like virtualenv. I
wish more publishers would move the installation instructions in these
sorts of books out of the first chapter and into an appendix, and let
the main content of the book focus on the primary subject matter.

The examples in chapters 2-4 start simple and build in complexity,
adding feature after feature. The progression is logical and it is
easy to skim over the repetitious parts of subsequent examples.
Having each chart style and annotation feature described will make the
book a good reference guide for someone using the library.

There were two minor issues with the presentation of the examples,
though. First, the author’s use of the non-standard IPython UI was a
little distracting, but it was explained in a later chapter that there
are some special interactive features of matplotlib which are best
used together with IPython. Second, the examples frequently use
“import as” to create abbreviated forms of module names. While it made
the code samples smaller, and may be how experienced matplotlib users
work, as a new user I found that it made the examples harder to
follow because I could not always tell where the functions were coming

The second half of the book includes three separate chapters covering
integration of matplotlib with different GUI toolkits, which felt a
little excessive. Since the same example application is presented, it
would have been less repetitious to see the chapters combined with
only the difference highlighted. The same comment applies to the three
sections on using matplotlib on the web. Using just one of the three
tools (CGI, Django, or Pylons) would have been sufficient, and left
space for more advanced examples or a deeper explanation.


My overall impression of the book is that it could make a useful
reference guide for matplotlib, but it didn’t have a lot of advice for
visualization issues in general. There are other more general books on
visualization techniques (including one from Packt), so the narrow
focus isn’t necessarily a problem if you are willing to look further.

Disclaimer: I received a free review copy of this book from the
publisher as part of my participation in the PyATL Book Club.

Book Review: Dive Into Python 3

I received a review copy of Mark Pilgrim’s updated `Dive Into Python
back in early November, but with the various holidays and
end-of-year activities I didn’t have a chance to read it until the
past week or so. I’m glad I waited until I had the time to sit down
and look over it carefully, because there is a lot of good material

Disclaimer: The review copy was free.

Quick Review

Inspired by Gene Ambaum and Bill Barnes’ review short-cuts, here’s
my review for the impatient reader:

Why I picked it up: Mark’s work has been the standard go-to guide
for learning Python for years now. I wanted to see what the new
version had to offer.

Why I finished it: No fluffy, contrived examples. Real-world code
and concise, clear discussion. And there’s no attempt to avoid
challenging topics.

I’d give it to: Beginner to intermediate programmers who want to
learn Python or improve their existing Python skills and experienced
programmers who want to learn about the new features of Python 3.

Completely Updated

Many of you may be familiar with, one of the
earliest major works published under an open license. The new edition
of the book has been updated to cover Python 3.1, including new
examples and entire new sections on language features not present in
earlier versions of the language. Starting with comprehensive setup
instructions to get Python installed, the introduction leaves no
excuses for not following along with the coding examples as you
read. It even includes advice for picking a text editor, in case you
don’t have one already.

Dives Right In

True to the title, the first code sample in Dive Into Python is a
complete program to convert integers to human-readable approximations
of different units. It uses I/O, dictionaries, functions (with
docstrings), new-style string formatting, and exceptions. On page 1.

Books about programming usually start with a bunch of boring
chapters about fundamentals and eventually work up to building
something useful. Let’s skip all that.

The more traditional discussion of integers, floats, strings, and data
structures is included early in the book, but that first example grabs
the attention better than the beginnings of many introductory texts.

Just the Facts

The explanation of that first program avoids fluff, staying on point
and addressing the reader as an intelligent learner. Striking that
balance between explaining the minutia of an example and letting the
reader discover the answer for themselves can be difficult, but Mark
finds it every time. This pattern is repeated throughout the book,
with each code sample being introduced, then examined in detail. Some
of the more important or interesting parts of the code are called out
for special discussion, as needed. And a few times sample code from
earlier in the book is reused in a later section. That code-reuse
reinforces the earlier point, while building on it to make the new

Real-world Advice

Throughout the book technical details about using Python (the language
and libraries) are mixed with solid developer advice on topics like
writing readable code, choosing tools, and getting the most out of
techniques such as testing. Chapter 14 covers HTTP web services, and
doesn’t stop with the basics of using httplib. In addition to talking
about third-party packages like httplib2, the chapter also stresses
the importance of creating well-behaved web clients and shows
techniques for doing so.

Beyond the Basics

The book also includes chapters on advanced topics such as porting
from Python 2 to Python 3 and packaging a library or application for
distribution. The porting chapter is actually a case study of porting
a real Python 2 library, chardet. It goes through the process of
running 2to3, and then works through examples of the conversion steps
that have to be done by hand. There’s a separate appendix with even
more detail about the types of automated translations 2to3 can make.

The more exotic your installation process is, the more exotic your
bug reports will be.

The packaging chapter stresses the need to follow standards and
conventions to make distributing your code easier – both for yourself
and and for your users. It covers the details of using distutils and
PyPI, licensing, and building source and binary distributions.


I can recommend Dive Into Python for any beginner or intermediate
programmer with a desire to pick up Python from scratch, or improve
their existing Python skills. More experienced programmers will find
the first few chapters fairly light reading, but the chapters on HTTP,
XML, and other advanced topics in the rest of the book helpful.

The porting and packaging chapters were of special interest to me.
This is starting to look like the year we should all be porting our
libraries to Python 3, so I imagine I’ll be re-reading the material on
2to3 a few times over the next few weeks.

Book Review: Citizen Engineer

Disclosure: I received a copy of this book for free from the
publisher as part of the PyATL Book Club.

The goal of Citizen Engineer, from Prentice Hall/Pearson Education,
is to awaken the socially responsible engineer in each of us. The
topics covered range from the environmental impact of product design
to the sociopolitical ramifications of intellectual property
law. Authors David Douglas (Senior VP of Cloud Computing, Sun), Greg
Papadopoulos (CTO and Executive VP of R&D, Sun), and John Boutelle
(freelance writer) share their experience in all of these areas to
create a thought-provoking introductory guide to the issues of modern
engineering practice.

Citizen Engineers are techno-responsible, environmentally
responsible, economically responsible, socially responsible
participants in the engineering community.

The authors begin by covering the background of what they call the
“Citizen Engineer” and why the issues are important. The premise of
the book is that it is no longer sufficient for engineers to work in
isolation in their labs. We must engage with practitioners of other
disciplines to bridge the gap between science and society. This is not
a new responsibility, and the role of “citizen engineer” is not new.
However, it is expanding as engineers have an ever greater need to
understand a broader range of fields to do their job well. Even if the
engineer doesn’t practice intellectual property law or environmental
science, they need to be familiar with the issues involved in order to
collaborate effectively.

They start the discussion by listing several external driving forces
that are changing the economics of the way good engineering is being
done. These include the environment, corporate social responsibility,
fraud and security concerns, privacy, digital goods and intellectual
property issues, and government regulation in all of those areas. The
book touches on each of these areas in turn.

Engineers who were once preoccupied with Moore’s Law are now dealing
with more laws…

Part 2 of the book is devoted to environmental issues and making the
case that the environment is something engineers can, should, and are
thinking about. Environmental impact analysis is complicated by many
variables and the fact that reducing impact in one area can increase it
in others. The authors approach the problem pragmatically. They start by
prioritizing changes based on the biggest impact, and ensuring that
impact is studied over the full life-cycle of the product. They also
point out that sustainability issues need to be considered “at scale” to
expose the true impact of small changes. For example, billions of people
use consumer products such as light bulbs, meaning even seemingly tiny
incremental improvements in efficiency or sustainability can have
sweeping global impact in energy consumption, materials used, and
natural resources consumed. Even a change to reduce the packaging weight
of a product will reduce the amount of fuel needed for shipping and
distribution, and depending on the scale that impact can be as big or
bigger than a change directly to the product itself.

… IT equipment often consumes less than half the power used in a
typical data center.

A little closer to home, the authors refer to research that says less
than half of the power used by a typical data center goes into
computing. The rest is lost as heat waste in the conversion to different
power levels, or is used to keep the computers cool. There is research
being done into more efficient cooling techniques, consolidation of
systems through virtualization, and alternative power setups with higher
voltage. Changing the hardware is not the only path to reducing power
consumption, though. More efficient code, and more efficient execution
of that code, provides opportunities for using less hardware in the
first place. That’s food for thought the next time you put off
optimization by saying, “cycles are cheap”.

Intellectual property laws are crafted to protect inventors and
creators and the companies that market their works.

Part 3 is titled “Intellectual Responsibility” and covers the
fundamentals of intellectual property law, including copyright,
trademark, and patents. I found the definitions of the IP terms such as
patent, copyright, and trademark in this section particularly helpful
for clarifying the roles each of those tools has in IP generally and
software specifically. I also like the way the authors separated the
technical background material from their own opinions on the subject.
Not everyone will agree with all of their conclusions, but the
delineation between fact and opinion avoids clouding the issue.

Chapter 13 digs into the basic types of open source licenses and the
decisions a software developer needs to make when deciding how to
license their creations. They also talk about forms of open licenses
for non-software products, such as Creative Commons. The authors have
copyrighted their book under a Creative Commons license (BY-NC-SA
3.0), and have downloadable copies of chapters available online at

The final section of the book, “Bringing it to Life”, talks about how
to apply some of the ideas from earlier chapters immediately, as well
as changes that are being made in engineering training so responsible
engineering practices are more central in future work. They talk about
cross-discipline training in law and environmental science and the
curriculum changes being tested in major universities. The book then
wraps up with examples from a selection of success stories from around
the world.

I recommend Citizen Engineer for engineers from all fields who
want a better understanding of some of the issues that are driving
changes in engineering practices. The clear and concise writing style
makes the book an easy read, without glossing over any difficult
topics. It does not attempt to provide an exhaustive reference
manual, but does give plenty of other resources for future research
and reading.