Customer Reviews: Understanding Computation: From Simple Machines to Impossible Programs
Your Garage Editors' Picks Amazon Fashion Learn more nav_sap_plcc_ascpsc $5 Albums Fire TV Stick Health, Household and Grocery Back to School Totes Amazon Cash Back Offer PilotWave7B PilotWave7B PilotWave7B  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Starting at $49.99 All-New Kindle Oasis DollyParton Shop Now

Format: Paperback|Change
Price:$33.99+ Free shipping with Amazon Prime
Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on July 6, 2013
Despite the fact that there's no _real_ reason to be apologetic, I also haven't yet reached the point in my career as a software developer where I've stopped apologizing for the fact that I have no "real" Computer Science Background. And/but that's exactly what draws me to books like "Understanding Computation" by Tom Stuart (O'Reilly, 2013). Stuart describes the books as for:

"...programmers who are curious about programming languages and the theory of computation, especially those who don't have a formal background in mathematics or computer science."

In other words, people like me. The people that Eric Miraglia described as the "liberal arts majors drafted into web-developer service during the dotcom boom". (source: Professional JavaScript for Web Developers 2nd ed.) Yes: the liberal artsy non-computer science degree holders that wound up doing computer sciencey type software work just the same. Smart people that nevertheless are exploring some of these concepts for the first time.

For a taste of what I mean, observe the following quote:

"In the end, syntax is only concerned with the surface appearance of programs, not with their meanings."

If that made you smile just a little bit, because you want to peel the onion layers away and get at the semantic questions underneath... then this book is for you.

Now before we go any further -- a couple words on what this book is **not**. This is _not_ a book about software engineering. "Big O notation" does not make an appearance here in the text, not once. It isn't that we aren't concerned with "clean code" or efficiency or scalability or any of that -- but those are just implementation details that are not particularly interesting when you're otherwise diving into language semantics and finite automata.

Instead, the kind of questions this book poses are more like:

- What _is_ a computer?
- How do you create one?
- How does a computer _compute_?
- How would you go about designing a language?
- Are there limits to computation? What are they?

These are fascinating questions, and reading this book was one of the first times where I really understood what separates "computer science" from "software engineering". The book is a fascinating read, even if it occasionally lapses into sentences like this:

"The NFA class automatically takes account of free moves -- we can see that when our NFA is started in state 3, it's already possible for it to be in state 2 or 3 before it has read any input -- so we won't need to do anything special in NFASimulation to support them."

_Awesome_, but a little opaque. And/but, there's quite a bit of this; for a "simple" book about foundational computer science thinking, there's a lot of complicated material. ("But this is why you're here, right? To dip your toes into this particular pool?") It's often challenging, but also rewarding. (And there's plenty of humor along the way, if you're paying attention.)

A year from now, when I'm settling in to re-read this one, I probably won't remember the details about pushdown automata or what formalisms define a "universal Turing machine". However, I'm going to remember the in-depth discussions of static typing vs. dynamism and the trade-offs between them. I'll remember that we went through some engrossing exercises where we built up integers and arithmetic operators from scratch (even if I don't remember the details). I'll remember the flirtatious foray into language design. I'll remember The Halting Problem and most of the gory details around the limits of computation. And another thing I'll remember, statements like this:

"The purpose of an expression is to be evaluated to produce another expression; a statement, on the other hand, is evaluated to make some change to the state of the abstract machine."

If you're "doing software" and you don't have a degree in computer science, I'm going to urge you to read this book. Even if you can't follow everything, you'll walk away with a lot of insight. (I'm particularly fond of the first and last thirds.) And if you _do_ have a CS degree... Well, it's still worth skimming.
0Comment| 43 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 31, 2013
Tom Stuart takes us on a journey through computation theory in a
thoroughly engaging manner.

I am new to the field of computers and
programming; I have spent only the past four years studying it
intensively. In University I studied applied Mathematics and as such,
I find most of my satisfaction in Programming in the areas of
computation and Functional Programming.

When I first head about *Understanding Computation* I was immediately
intrigued, though I knew nothing more about the book than it's title.
I picked it up a few days later and was immediately captivated. The
subject matter is interesting and presented in a clear and consistent

Tom Stuart has put together what I consider to be an essential
companion book for any software enthusiast's course of self study. I
personally have found the book educational and it has found its place
next to my copy of Michaelson's "An Introduction To Functional
Programming Through Lambda Calculus". Personally, I found the
discussion on big and operational semantics the most enlightening, as
I have never had any exposure to it previously.

I do believe that there are portions of the book which suffer from
Ruby's syntax and structure, particularly in the earlier chapters
where the reader builds a pipeline of methods within a class. Although
this con is minor, a novice reader may find it distracting; this is a
very minor issue in an otherwise fantastic book.
11 comment| 15 people found this helpful. Was this review helpful to you?YesNoReport abuse
on September 13, 2013
Rather than anything like a textbook, Understanding Computation is a guided tour of some of the most interesting and fundamental aspects of computation, presented in a way that doesn't rely on dry theoretical proofs or hard-to-follow mathematical explanations.

The author uses a high level programming language to demonstrate some simple systems that demonstrate interesting computational principles, making this a really excellent text for those who have entered the world of computing from backgrounds other than computer science. However, even if you are familiar with the concepts the book is still a delight to read, thanks to the author's clear and engaging style, thorough examples (all of which have made available to download and experiment with yourself). Even if you consider yourself a computer science expert and already know about everything the book covers, I am confident that you'll enjoy taking this journey.

I really cannot recommend this enough; if you have any curiosity at all about what a Turing machine is, and what makes it special, this book will answer those questions and leave you ready and eager to learn more.
0Comment| 7 people found this helpful. Was this review helpful to you?YesNoReport abuse
on May 30, 2014
Most books talking about automatons, regular expressions and related subjects are made really hard to digest by have a very formal, mathematical approach and not being straightforward to apply into programming concepts. This book does have depth but keeps it simple by showing you actual code instead of just mathematical symbols. I thoroughly enjoyed it and will probably come back to it soon.
0Comment| 4 people found this helpful. Was this review helpful to you?YesNoReport abuse
on August 10, 2013
I've gone through the first part of the book, and it is great up until now.
There are some code examples in this book that are not explained and are hard to understand, maybe the book would be better off without examples the author does not plan to explain adequately, or code examples that do not help the reader understand the subject being treated.

Most of the code examples that are not thoroughly explained are *extra* content, but I think they degrade the quality of the book instead of improve it.
0Comment| 4 people found this helpful. Was this review helpful to you?YesNoReport abuse
on January 8, 2016
I want to be interested in the material, but unless you're already pretty adept at Ruby there is basically no explanation of how to run the provided sample code, which itself is not at all clearly matched to the listings in the book. I give it three stars because the prose in the book seems actually quite good - I just can't follow along by running any of the examples, or maybe I'm not sufficiently motivated to figure it out on my own. Disappointed.
11 comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
on August 18, 2016
This book won't give you the deep mathematical underpinnings of computation, but it provides a great starting point for understanding how computer scientists think about computation and could provide a solid auxiliary reference for CS students touching computation for the first time.
0Comment|Was this review helpful to you?YesNoReport abuse
on July 2, 2013
A fantastic introduction to the theory of computation for the working programmer.Covers topics like writing a programming language,automata theory etc in a really accessible manner and uses ruby to demonstrate the principles. Must read !.
0Comment| 9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 21, 2013
This book does what it promises to do - take the reader from the most basic simplifications of computers (finite automata), through more complex simplifications (Turing machines) to reasoning about 'impossible' problems (The quotation marks are added because these problems will surely be solved one day or another by some clever fellow with too much brain activity and spare time, but are impossible for now). I really enjoyed the fact that the author was able to use Ruby code to illuminate his examples, which (me being a programmer) made them much easier to understand (easer being the operative word, this s*** is still complex as balls) than the mathematical notation commonly used by textbooks.

However, I feel that Mr. Stuart (much like all other authors of complicated, technical books I've read) falls into the trap of following a very predefined path for his line of reasoning, which leaves the reader with the feeling (at least, this was the case for me) that this is 'all planned out' and that there's a lot of information he intentionally leaves out or doesn't mention (this might not even be the case, but it still FEELS like this - which is a problem). If you have no idea what I'm talking about, read the book, and if you still don't know what I'm talking about then feel free to shake your head condescendingly.

Now, my interest in this particular field of computer science is cursory at best, which might not make me the ideal fit for Mr. Stuart's target audience, so if you get a major hard-on when syntax trees are generated (seek help) then you might get more out of this book than me.

That being said, he managed to peak my interest in concepts I felt were mind-numbingly boring in university (such as non-deterministic and deterministic finite automata), so kudos to Mr. Stuart for that. This book is a possible gold mine for the more interested pupil, especially when considering the problem of Turing completeness (in which he completely lost me, mid-chapter I put the book down and went to the fridge and rewarded myself with a beer for my efforts), reasoning about programs and (wait for it) generation of syntax trees.

All in all a good read, if you're into this sort of thing.
22 comments| 8 people found this helpful. Was this review helpful to you?YesNoReport abuse
on September 12, 2015
0Comment|Was this review helpful to you?YesNoReport abuse