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.

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.

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.

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.

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.

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.

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

Tom Stuart takes us on a journey through computation theory in athoroughly engaging manner.I am new to the field of computers andprogramming; I have spent only the past four years studying itintensively. In University I studied applied Mathematics and as such,I find most of my satisfaction in Programming in the areas ofcomputation and Functional Programming.When I first head about *Understanding Computation* I was immediatelyintrigued, though I knew nothing more about the book than it's title.I picked it up a few days later and was immediately captivated. Thesubject matter is interesting and presented in a clear and consistentmanner.Tom Stuart has put together what I consider to be an essentialcompanion book for any software enthusiast's course of self study. Ipersonally have found the book educational and it has found its placenext to my copy of Michaelson's "An Introduction To FunctionalProgramming Through Lambda Calculus". Personally, I found thediscussion on big and operational semantics the most enlightening, asI have never had any exposure to it previously.I do believe that there are portions of the book which suffer fromRuby's syntax and structure, particularly in the earlier chapterswhere the reader builds a pipeline of methods within a class. Althoughthis con is minor, a novice reader may find it distracting; this is avery minor issue in an otherwise fantastic book.