Understanding Computation und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr

Loggen Sie sich ein, um 1-Click® einzuschalten.
Jetzt eintauschen
und EUR 6,50 Gutschein erhalten
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Keine Abbildung vorhanden

Beginnen Sie mit dem Lesen von Understanding Computation auf Ihrem Kindle in weniger als einer Minute.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Understanding Computation: From Simple Machines to Impossible Programs [Englisch] [Taschenbuch]

Tom Stuart
5.0 von 5 Sternen  Alle Rezensionen anzeigen (2 Kundenrezensionen)
Preis: EUR 24,95 kostenlose Lieferung Siehe Details.
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Nur noch 5 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Dienstag, 28. Oktober: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 15,13  
Taschenbuch EUR 24,95  


31. Mai 2013
Finally, you can learn computation theory and programming language design in an engaging, practical way. Understanding Computation explains theoretical computer science in a context you’ll recognize, helping you appreciate why these ideas matter and how they can inform your day-to-day programming. Rather than use mathematical notation or an unfamiliar academic programming language like Haskell or Lisp, this book uses Ruby in a reductionist manner to present formal semantics, automata theory, and functional programming with the lambda calculus. It’s ideal for programmers versed in modern languages, with little or no formal training in computer science. * Understand fundamental computing concepts, such as Turing completeness in languages * Discover how programs use dynamic semantics to communicate ideas to machines * Explore what a computer can do when reduced to its bare essentials * Learn how universal Turing machines led to today’s general-purpose computers * Perform complex calculations, using simple languages and cellular automata * Determine which programming language features are essential for computation * Examine how halting and self-referencing make some computing problems unsolvable * Analyze programs by using abstract interpretation and type systems

Wird oft zusammen gekauft

Understanding Computation: From Simple Machines to Impossible Programs + Good Math: A Geek's Guide to the Beauty of Numbers, Logic, and Computation (Pragmatic Programmers) + Seven Concurrency Models in Seven Weeks: When Threads Unravel (The Pragmatic Programmers)
Preis für alle drei: EUR 70,85

Die ausgewählten Artikel zusammen kaufen

Kunden, die diesen Artikel gekauft haben, kauften auch


  • Taschenbuch: 329 Seiten
  • Verlag: O'Reilly & Associates; Auflage: 1 (31. Mai 2013)
  • Sprache: Englisch
  • ISBN-10: 1449329276
  • ISBN-13: 978-1449329273
  • Größe und/oder Gewicht: 22,9 x 17,9 x 2 cm
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (2 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 48.699 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)


Über den Autor und weitere Mitwirkende

Tom is chief scientist at Expert Human. He is an experienced, passionate computer scientist and programmer. He work as a freelance consultant, mentor and trainer, helping all kinds of companies to improve the quality and clarity of their approach to creating software products, usually on the web. Sometimes this means spending a month writing code for them; at other times it means encouraging them to rethink their product, re-educate their teams, rewrite their tests, or ruthlessly refactor their code. He has lectured on compilers at the University of Cambridge, helped organize the Ru3y Manor conference, and is a member and speaker of the London Ruby User Group.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


4 Sterne
3 Sterne
2 Sterne
1 Sterne
5.0 von 5 Sternen
5.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
Format:Kindle Edition
Understanding Computation (From Simple Machines to Impossible Programs), by Tom Stuart, is an absolute gem of a book. It's described as:

"Finally, you can learn computation theory and programming language design in an engaging, practical way. Understanding Computation explains theoretical computer science in a context you’ll recognize, helping you appreciate why these ideas matter and how they can inform your day-to-day programming."

And it does exactly that. If you're a self-taught programmer, or a hobbyist who wants to learn more about the theoretical side of computer science, without drowning in research papers, I cannot recommend a better book. Using the ruby language as the starting point, the author moves concisely and clearly through parsers, DFA and NFA, regular expressions, and alone for these components would be worth recommending. Readers will get a solid understanding of how these common and critical components of most programming languages work, without actually getting lost in the complex source code of a full real-world implementation in a modern day language.

I don't recall another book that manages to treat Turing Machines in such a practical way, and expands into the lambda calculus, and the final section of the book covers core computer science concepts such as non-computability (the halting problem) in a way that will bring relief to many future computer science students.

With its absolute clarity, practical and engaging style, this book will be a classic for years to come.
War diese Rezension für Sie hilfreich?
5.0 von 5 Sternen Great book if you speak Ruby or Automata 6. Oktober 2013
Format:Taschenbuch|Verifizierter Kauf
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.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 3.8 von 5 Sternen  9 Rezensionen
33 von 37 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen the computer science book for non-computer science software engineers 7. Juli 2013
Von R. Friesel Jr. - Veröffentlicht auf Amazon.com
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.
11 von 11 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A fantastic Book 1. August 2013
Von Sean Williamson - Veröffentlicht auf Amazon.com
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.
5 von 5 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Easy and engaging introduction to computational ideas 13. September 2013
Von James - Veröffentlicht auf Amazon.com
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.
2 von 2 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen From finite state machine to turing machines, in a digstible, example driven way 30. Mai 2014
Von Emmanuel Oga - Veröffentlicht auf Amazon.com
Format:Kindle Edition|Verifizierter Kauf
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.
4 von 5 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Great Practical Introductory Book 10. August 2013
Von Marcel - Veröffentlicht auf Amazon.com
Format:Kindle Edition|Verifizierter Kauf
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.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Erster Beitrag:
Eingabe des Log-ins

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen

Ähnliche Artikel finden

Ihr Kommentar