Understanding Computation: From Simple Machines to Impossible Programs 1st Edition

I loved loved loved this book! It was some of the best parts of grad school, but repackaged into a form that was accessible to someone who hasn’t seen academia in decades. I just about read it in one sitting... Couldn’t put it down.

This is one of the finer books on computer science you will find. Especially since it was published in the last few years I find that particularly remarkable as most of the classic had been written in the 70's or 80's. Not saying this is a classic yet, but well worth the read.

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.

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.

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.

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.

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 !.

This book was very poorly written, confusing and badly organized. Rather than presenting computation from a logical, evolutionary point of view, this book tried to be a collection of academic papers, jumping in with no rhyme or reason.

This is a fantastic book. The author manages to explain complex topics in such a way that is easy to understand. If you are like me, a self taught programmer wanting to learn all the big ideas in computer science then don't hesitate to buy this book! For example, if you ever struggled with the idea of non-determinism, as I did, this is explained in the chapter on finite state machines in such a way that it really just clicks straight away! So, the author really knows his stuff and is able to explain in a clear and concise way. The code is in Ruby and there is a quick primer in the first chapter with enough Ruby to get you through the book. 5 stars!

I have been enjoying this book. I like the way they implement everything in Ruby rather than leaving it very theoretical. I definitely would recommend this to any programmer looking to improve their computer science background a bit, especially if you're not already familiar with state machines, automatons, universal turing machines, lambda calculus, parsers, interpreters, and compilers. This books introduces those terms in a very concrete way *using code* such that you'll really know exactly what it means afterwards.

I bought this book after the rave reviews it received from the Ruby Rogues Podcast (Amazon does not allow links, so you have to search for it) - and so far, I haven't been disappointed! I'm about halfway through and many of the concepts I had previously learned the mathematical way became much, much clearer still. I'm just not sure exactly if this book is really aimed at readers with "no formal background in mathematics or computer science" as the author suggests. Knowing about Turing machines, semantics, grammars and such certainly helped me through some of the denser parts.I have to confess that my Ruby isn't all that great though and I have to read and re-read the code blocks a lot. My verdict would be that you should speak Ruby quite well _or_ have some basic understanding of computation before you pick this one up. If you lack both, this book might be a little too hard for an enjoyable read.

Having read the table of contents, I thought this book would explain in detail the CS ideas hear all the time, like that a certain deterministic pattern is "Turing complete". Instead of details and understanding, you get pages of dense source code and lots of white space. I've been fooled too many times by the promise of an O'Reilly book, never again.

The author explains a key concepts of computation in ways that I never thought possible. The exposition is clear and well presented. These are concepts I struggled with while at university... I wish this book was released while I was CS student!