en-US Tue, 15 Apr 2025 17:31:09 -0700 60 144 41 /images/layout/goodreads_logo_144.jpg 293991
In Out of their Minds, readers will hear the Newtons and Euclids of the computer age as they talk about their discoveries in information technology that have changed forever the way we live, work, and think about the world. Based on interviews by freelance writer Cathy Lazere and the expertise of computer scientist Dennis Shasha, Out of their Minds introduces readers to fifteen of the planet's foremost computer scientists, including eight winners of the Turing Award, computing's Nobel Prize. The scientists reveal themselves in fascinating anecdotes about their early inspirations and influences, their contributions to computer science, and their thoughts on its explosive future. These are the programmers whose work]]> 302 Dennis E. Shasha 0387982698 Mundy 0 3.85 1995
author: Dennis E. Shasha
name: Mundy
average rating: 3.85
book published: 1995
rating: 0
read at:
date added: 2025/04/15
shelves: algorithms, computer-science, history, re-shelved-for-later, to-read, history-of-math
review:

]]> 12625589 Turing’s Cathedral, George Dyson focuses on a small group of men and women, led by John von Neumann at the Institute for Advanced Study in Princeton, New Jersey, who built one of the first computers to realize Alan Turing’s vision of a Universal Machine. Their work would break the distinction between numbers that mean things and numbers that do things—and our universe would never be the same.

Using five kilobytes of memory (the amount allocated to displaying the cursor on a computer desktop of today), they achieved unprecedented success in both weather prediction and nuclear weapons design, while tackling, in their spare time, problems ranging from the evolution of viruses to the evolution of stars.

Dyson’s account, both historic and prophetic, sheds important new light on how the digital universe exploded in the aftermath of World War II. The proliferation of both codes and machines was paralleled by two historic the decoding of self-replicating sequences in biology and the invention of the hydrogen bomb. It’s no coincidence that the most destructive and the most constructive of human inventions appeared at exactly the same time.

How did code take over the world? In retracing how Alan Turing’s one-dimensional model became John von Neumann’s two-dimensional implementation, Turing’s Cathedral offers a series of provocative suggestions as to where the digital universe, now fully three-dimensional, may be heading next.]]> 505 George Dyson Mundy 5 3.57 2012
author: George Dyson
name: Mundy
average rating: 3.57
book published: 2012
rating: 5
read at: 2023/11/12
date added: 2025/04/15
shelves: artificial-life, computer-science, history, algorithms, game-theory, logic, mathematics, social-sciences, history-of-math
review:

]]> 2765979 564 Patrick Van Fleet 047018311X Mundy 4 4.33 2008
author: Patrick Van Fleet
name: Mundy
average rating: 4.33
book published: 2008
rating: 4
read at: 2025/04/14
date added: 2025/04/14
shelves: algorithms, computer-science, discrete-math, mathematics
review:

]]> 1053394 316 Franz Baader 0521779200 Mundy 0 4.29 1998
author: Franz Baader
name: Mundy
average rating: 4.29
book published: 1998
rating: 0
read at:
date added: 2023/08/26
shelves: artificial-life, computer-science, discrete-math, formal-grammars, highly-regarded, logic, mathematics, references, linguistics, generative_art, algorithms, to-read
review:

]]> 301563 as described 252 William Poundstone 0809252023 Mundy 4 3.93 1984
author: William Poundstone
name: Mundy
average rating: 3.93
book published: 1984
rating: 4
read at: 2023/08/12
date added: 2023/08/12
shelves: algorithms, artificial-life, biology, chemistry, cognitive-science, computer-science, dynamical-systems, formal-grammars, mathematics, philosophy, philosophy-of-physics, references
review:
A lot more detailed than your average "pop-sci" book, especially when it came to Conway's Game of Life / cellular automata sections (whereas the physics sections were just meh). It is a bit dated though, but so is the majority of the artificial life field wrt popularity nowadays, with deep learning hogging all the spotlight. Also somewhat cool, in that at the end it even includes the code for Life written in an Assembler language!
]]> 14652263 850 Stephen Lucci 1936420236 Mundy 5 4.30 2011
author: Stephen Lucci
name: Mundy
average rating: 4.30
book published: 2011
rating: 5
read at: 2013/12/31
date added: 2022/10/31
shelves: cognitive-science, computer-science, linguistics, machine-learning, mathematics, references, highly-regarded, logic, algorithms, artificial-life
review:

]]> 58354874 Summary

Generative Art presents both the technique and the beauty of algorithmic art. The book includes high-quality examples of generative art, along with the specific programmatic steps author and artist Matt Pearson followed to create each unique piece using the Processing programming language.
About the Technology
Artists have always explored new media, and computer-based artists are no exception. Generative art, a technique where the artist creates print or onscreen images by using computer algorithms, finds the artistic intersection of programming, computer graphics, and individual expression. The book includes a tutorial on Processing, an open source programming language and environment for people who want to create images, animations, and interactions.
About the Book
Generative Art presents both the techniques and the beauty of algorithmic art. In it, you'll find dozens of high-quality examples of generative art, along with the specific steps the author followed to create each unique piece using the Processing programming language. The book includes concise tutorials for each of the technical components required to create the book's images, and it offers countless suggestions for how you can combine and reuse the various techniques to create your own works.

Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.
What's Inside
The principles of algorithmic art
A Processing language tutorial
Using organic, pseudo-random, emergent, and fractal processes

========================================�=========
Table of Contents
Part 1 Creative Coding
Generative Art: In Theory and Practice
Processing: A Programming Language for ArtistsPart 2 Randomness and Noise

The Wrong Way to Draw A Line
The Wrong Way to Draw a Circle
Adding Dimensions
Part 3 Complexity
Emergence
Autonomy
Fractals]]> 311 Matt Pearson 1638352437 Mundy 0 0.0 2011
author: Matt Pearson
name: Mundy
average rating: 0.0
book published: 2011
rating: 0
read at:
date added: 2022/06/15
shelves: to-read, art, algorithms, computer-science, generative_art
review:

]]> 11039999 184 Susanne Pfalzner 0521495644 Mundy 0 0.0 1996
author: Susanne Pfalzner
name: Mundy
average rating: 0.0
book published: 1996
rating: 0
read at:
date added: 2022/03/14
shelves: to-read, algorithms, computer-science, discrete-math, graph-theory, mathematics, physics, statmech-thermo-it
review:

]]> 37571342 An accessible and rigorous textbook for introducing undergraduates to computer science theoryWhat Can Be Computed? is a uniquely accessible yet rigorous introduction to the most profound ideas at the heart of computer science. Crafted specifically for undergraduates who are studying the subject for the first time, and requiring minimal prerequisites, the book focuses on the essential fundamentals of computer science theory and features a practical approach that uses real computer programs (Python and Java) and encourages active experimentation. It is also ideal for self-study and reference.The book covers the standard topics in the theory of computation, including Turing machines and finite automata, universal computation, nondeterminism, Turing and Karp reductions, undecidability, time-complexity classes such as P and NP, and NP-completeness, including the Cook-Levin Theorem. But the book also provides a broader view of computer science and its historical development, with discussions of Turing's original 1936 computing machines, the connections between undecidability and Gödel's incompleteness theorem, and Karp's famous set of twenty-one NP-complete problems.Throughout, the book recasts traditional computer science concepts by considering how computer programs are used to solve real problems. Standard theorems are stated and proven with full mathematical rigor, but motivation and understanding are enhanced by considering concrete implementations. The book's examples and other content allow readers to view demonstrations of—and to experiment with—a wide selection of the topics it covers. The result is an ideal text for an introduction to the theory of computation.

An accessible and rigorous introduction to the essential fundamentals of computer science theory, written specifically for undergraduates taking introduction to the theory of computationFeatures a practical, interactive approach using real computer programs (Python in the text, with forthcoming Java alternatives online) to enhance motivation and understandingGives equal emphasis to computability and complexityIncludes special topics that demonstrate the profound nature of key ideas in the theory of computationLecture slides and Python programs are available at whatcanbecomputed.com]]> 408 John MacCormick 1400889847 Mundy 5 Motivation
If you've never heard of why someone would study the "Theory of Computation" and how this differs from something perhaps more tangible like programming or software engineering, you might come to the conclusion that this is "all just theory"...*waves around hand in the air in a useless circular manner*, but I'd beg you to not jump to this thought too soon! It's not that the latter is practical, while the former is just theory, but rather that what we call "programming" or "software engineering" is usually very specific to a certain set of technologies of a specific era or even a specific hardware implementation, whereas the former "theory" contains concepts that can be applied agnostic of the hardware you are dealing with, agnostic to the time period you are living in, agnostic of the specific programming language you are using, and even in my case, agnostic to the field at which you are even applying this knowledge to!

Computing is a very general concept that can be applied to multiple fields and domains of expertise and is much more a "way of thinking" and collection of unique logical tools and methods for solving problems in whatever domain, either software, linguistics, mathematics, electrical engineering, philosophy, botany, physics, and in my case, the foundations of biology! It is kind of unfortunate given the name, but "computing" is not about computers per se, but rather about the nature of problem solving, talking about certain limits to how efficiently a problem can be solved, and even figuring out if our problem even has a way of solving it to begin with (which you'll come to learn is very different from merely checking whether an answer is correct)! The nature of time, memory, space, efficiency, and representation are all topics that are explored in this area.

Background
Having just recently finished a Formal Grammars & Automata Theory course at the local university where we used the canonical textbook by Sipser (my review of that book here), I'm going to say that that book plus this one are the main reasons why I was able to keep up with the course and not fall behind. Whereas the Sipser book reads like a more traditional definition-lemma-proof book that you might encounter in some fields of math, this book is geared towards those that are practically-minded, where instead of proofs you get all your examples in modern-day Python code (with the online version of the book also giving examples in Java code as well). An example of that can be seen here:



I believe this is crucial for those that *learn by doing* or prefer a "visceral understanding", and for those that are lucky enough to be able to learn through both methods, they would be well-served by complementing this book with the Sipser one. Another thing to note is that the language and layout of this book is quite modern as well. It's hard to describe, but there's something somewhat old and dated about the Sipser book that sometimes might put one to sleep, whereas this book is just clean and crisp. Like check out this way of illustrating how our programs interact with each other (which in Sipser's case would instead just be one giant proof). Much more intuitive, huh?



It might just be the use of colors, extra spacing, and higher quality thicker paper, but little things like these do wonders for those that engage in long periods of study late at night with lower-than-usual lighting conditions, or maybe those of us who do a bit more rough-handling by bringing a book to a park or something (although I admit that this extra quality probably has the downside of raising the book's publishing costs).

For those that are thinking of using this book to teach, I think I should quickly note that there are some differences between learning from this book versus learning from Sipser's. Much of the more advanced theoretical material that is covered in Sipser's book has been eliminated from this book, with the main target audience for this book being at the undergraduate level. You can check out the Content section below for more, but this book basically includes the same material as Sipser's, minus the following from the "Computability" section: unrestricted grammars, recursive function theory, lambda calculus, recursively enumerable, recursive, and non-recursive languages, and minus the following from the "Complexity" section: space complexity, hierarchy theorems, circuit complexity, randomness, and interactive proofs. It also teaches concepts in a bit of a non-traditional order, with Turing machines being covered before finite automata, but this makes sense given that this book covers a practical approach that emphasizes computer programs first.

For the self-study people out there thinking about prerequisites, the author does an incredible job keeping requirements to a minimum (much more than Sipser in my opinion), in that basic high school level algebra will suffice (no calculus needed), and programming fluency is also minimal given that everything is in readable Python (and even at that, the programs are very simple in their complexity). As a disclaimer, although I'm just a data scientist with a former background in neuroscience, I have invested a non-trivial amount of both non-formal + official time in coursework such as logic, set theory, and generally "pure math" areas, and I was also concurrently going through another official and very complementary proof-heavy logic course in Undecidability & Incompleteness, so my theoretical fluency is probably a bit more than needed for this book, and given that most data scientists are well-versed in reading and writing Python, a book like this would be very much welcomed compared to something like Sipser's. So yeah, just take my review with all that in mind.

Other Helpful Material
When studying some subject I always recommend trying to learn from multiple sources because you can't always guarantee that you'll never "get stuck" on some concept or section of a book. I've found that sometimes having multiple perspectives and different people explaining things to me can help. I've already mentioned working through this book in tandem with Sipser's, but two other books I was also reading in parallel that I recommend are The Annotated Turing and Gödel's Theorem: An Incomplete Guide to Its Use and Abuse, the former of which I highly recommend for its excellent historical treatment of Alan Turing's original 36-page paper establishing what is now known as the Turing Machine, and the latter book whose mathematical & philosophical topic arguably spurred the development of the former (for a short & neat explanation of this for the layman, ).

I usually like accompanying my studies with historical background like this to not only help motivate me, but also to give me a bigger "forest-over-trees" picture and context as to why these ideas were even formed to begin with, how this fits into the grander historical narrative, and why I should even care. It's also somewhat fun for my socially-inclined primate brain to know the people and controversies behind such ideas, which provides a useful scaffold and cognitive framework to remember this material much better and for longer (if you especially enjoy this, see the book Exact Thinking in Demented Times: The Vienna Circle and the Epic Quest for the Foundations of Science).

In addition to the aforementioned books, I would also recommend going through which covers the Theory of Computing and solves a lot of practice problems with you (the latter of which is key to becoming fluent with this material!) Furthermore, you can also download all the Python and Java code for this course . Hopefully all that linked material proves helpful on your learning journey :)

Content
Somewhat similar to Sipser's book and similar to most "Theory of Computation" curricula, this book is broken up into 2 main parts: Computability Theory and Complexity Theory.

In the first section of this book we go over what can and cannot be computed by a program (using Python programs as examples), as well as some impossible Python programs. The Halting problem and proof by contradiction was smartly done here using practical examples. We then go over various computational problems, beginning with graphs, alphabets, strings, and languages, the different categories of problems (search, optimization, threshold, function, decision, etc), recognizing vs. deciding languages, and then finally the model of a Turing machine. I really think this latter part is how college courses should be teaching this material and I wish my official university course did something similar. Oftentimes it is very time consuming to draw Turing machines and then when it gets more complicated students are often forced to write pseudo-code and line-by-line high-level versions of algorithms on paper. Using this author's approach of writing tangible Python programs I think is quite superior in pedagogical strategy as there are multiple ways students can experiment, play, and "check" their programs in real-time, which grants much more intuition than something like an algorithm written on paper that can only really be "checked" for correctness once it's turned-in to an external grader/teacher and then handed back. The feedback loop for learning is just too wide and sometimes non-existent for the latter to really have a strong effect on one's learning. It is because of this that I think a book like this should be praised quite highly for moving the education field forward.

Going back to the material, after variations of Turing machines and then introduction to universal Turing machines, we then are taught the technique of reductions (for an interesting article on "time-traveling Turing machines" and closed-timelike curves in computation, by quantum computing theorist, Scott Aaronson). As we can see, compared to the Sipser book this book explains how the reduction technique in proofs works visually:



And here:



This is then followed up with nondeterminism, and finally DFAs and NFAs, regular expressions, and our famous pumping lemma. Here is where we can note the "flip-flop" order of this book compared to a more traditional curriculum which usually starts off with this material. Somewhat of an aside, but I really wished this book at least introduced or covered a little bit of context-sensitive grammars, since that was my primary interest and motivation for even taking this course to begin with (due to its relationship with cellular automata, lindenmayer systems, artificial life, and theoretical biology, all of which ). None of the books I have encountered so far even do this! Gah!

The book then moves on to the second half of the material concerning computational complexity theory, moving away from asking questions about "possibility" and more towards questions of "efficiency". Big-O notation is introduced, in addition to your usual complexity classes. Further depth is then achieved in the next section with the reader delving into polynomial and exponential complexities, with the next two sections covering polynomial-time mapping reductions and NP-completeness, with a nice diagram showing the polyreductions used in this book:



I believe this is where an author's more practical strategy of teaching through code shines here, as this allows one to actually see where these problems apply in their daily workplace settings or even maybe another course they might take in the future such as in cryptography, networking, or algorithms. The book concludes with more history and theoretically-bent material with the famous Church-Turing thesis, undecidability of Peano arithmetic, Karp's problems and reductions, etc.

Conclusion
Overall, this book introduced highly fascinating material at the intersection of multiple disciplines of computer science, logic, math, philosophy, electrical engineering, linguistics, etc. The amount of accompanying explanatory discussion along with the very practically-minded approach via Python programs makes this book highly recommended in my opinion, especially for self-study.

My only comment for improvement is to include some introductory material in the computability section on *context-sensitive grammars! I would've loved to have an official and well-backed source that I could reference and learn this from (especially since I haven't yet come across a theory of computing book that does just that). And also, although it might seem a tad too advanced, I do think maybe a brief introduction to what is known as which observes the fundamental relationships between computation / programming languages, formal logic / type theory, and category theory / topology to be a highly relevant and significant perspective which would allow the student coming from another field to see all the fascinating connections linking everything together, or alternatively help a student to branch out to other fields to which the theory of computation can be applied. This "Rosetta stone" is a marvelous way to bring this book and field to higher prominence and relevance today. I know this book is aimed towards undergrads, but I think if the author chose to incorporate just these two aforementioned materials they would probably usurp the Sipser book's reign on Theory of Computing curricula!

Thanks for reading :)

*EDIT: From the comments below with Ritu, I was motivated to take a look at the textbook Automata, Computability and Complexity: Theory and Applications by Elaine Rich and just found out that by way of the Myhill–Landweber–Kuroda theorem! So technically to be fair, I guess the above textbook by MacCormick indirectly covered CSGs whether the author intended to or not.]]> 4.67
author: John MacCormick
name: Mundy
average rating: 4.67
book published:
rating: 5
read at: 2021/06/11
date added: 2022/01/20
shelves: algorithms, computer-science, complexity-theory, discrete-math, highly-regarded, formal-grammars, graph-theory, logic, mathematics, references, python
review:
Motivation
If you've never heard of why someone would study the "Theory of Computation" and how this differs from something perhaps more tangible like programming or software engineering, you might come to the conclusion that this is "all just theory"...*waves around hand in the air in a useless circular manner*, but I'd beg you to not jump to this thought too soon! It's not that the latter is practical, while the former is just theory, but rather that what we call "programming" or "software engineering" is usually very specific to a certain set of technologies of a specific era or even a specific hardware implementation, whereas the former "theory" contains concepts that can be applied agnostic of the hardware you are dealing with, agnostic to the time period you are living in, agnostic of the specific programming language you are using, and even in my case, agnostic to the field at which you are even applying this knowledge to!

Computing is a very general concept that can be applied to multiple fields and domains of expertise and is much more a "way of thinking" and collection of unique logical tools and methods for solving problems in whatever domain, either software, linguistics, mathematics, electrical engineering, philosophy, botany, physics, and in my case, the foundations of biology! It is kind of unfortunate given the name, but "computing" is not about computers per se, but rather about the nature of problem solving, talking about certain limits to how efficiently a problem can be solved, and even figuring out if our problem even has a way of solving it to begin with (which you'll come to learn is very different from merely checking whether an answer is correct)! The nature of time, memory, space, efficiency, and representation are all topics that are explored in this area.

Background
Having just recently finished a Formal Grammars & Automata Theory course at the local university where we used the canonical textbook by Sipser (my review of that book here), I'm going to say that that book plus this one are the main reasons why I was able to keep up with the course and not fall behind. Whereas the Sipser book reads like a more traditional definition-lemma-proof book that you might encounter in some fields of math, this book is geared towards those that are practically-minded, where instead of proofs you get all your examples in modern-day Python code (with the online version of the book also giving examples in Java code as well). An example of that can be seen here:



I believe this is crucial for those that *learn by doing* or prefer a "visceral understanding", and for those that are lucky enough to be able to learn through both methods, they would be well-served by complementing this book with the Sipser one. Another thing to note is that the language and layout of this book is quite modern as well. It's hard to describe, but there's something somewhat old and dated about the Sipser book that sometimes might put one to sleep, whereas this book is just clean and crisp. Like check out this way of illustrating how our programs interact with each other (which in Sipser's case would instead just be one giant proof). Much more intuitive, huh?



It might just be the use of colors, extra spacing, and higher quality thicker paper, but little things like these do wonders for those that engage in long periods of study late at night with lower-than-usual lighting conditions, or maybe those of us who do a bit more rough-handling by bringing a book to a park or something (although I admit that this extra quality probably has the downside of raising the book's publishing costs).

For those that are thinking of using this book to teach, I think I should quickly note that there are some differences between learning from this book versus learning from Sipser's. Much of the more advanced theoretical material that is covered in Sipser's book has been eliminated from this book, with the main target audience for this book being at the undergraduate level. You can check out the Content section below for more, but this book basically includes the same material as Sipser's, minus the following from the "Computability" section: unrestricted grammars, recursive function theory, lambda calculus, recursively enumerable, recursive, and non-recursive languages, and minus the following from the "Complexity" section: space complexity, hierarchy theorems, circuit complexity, randomness, and interactive proofs. It also teaches concepts in a bit of a non-traditional order, with Turing machines being covered before finite automata, but this makes sense given that this book covers a practical approach that emphasizes computer programs first.

For the self-study people out there thinking about prerequisites, the author does an incredible job keeping requirements to a minimum (much more than Sipser in my opinion), in that basic high school level algebra will suffice (no calculus needed), and programming fluency is also minimal given that everything is in readable Python (and even at that, the programs are very simple in their complexity). As a disclaimer, although I'm just a data scientist with a former background in neuroscience, I have invested a non-trivial amount of both non-formal + official time in coursework such as logic, set theory, and generally "pure math" areas, and I was also concurrently going through another official and very complementary proof-heavy logic course in Undecidability & Incompleteness, so my theoretical fluency is probably a bit more than needed for this book, and given that most data scientists are well-versed in reading and writing Python, a book like this would be very much welcomed compared to something like Sipser's. So yeah, just take my review with all that in mind.

Other Helpful Material
When studying some subject I always recommend trying to learn from multiple sources because you can't always guarantee that you'll never "get stuck" on some concept or section of a book. I've found that sometimes having multiple perspectives and different people explaining things to me can help. I've already mentioned working through this book in tandem with Sipser's, but two other books I was also reading in parallel that I recommend are The Annotated Turing and Gödel's Theorem: An Incomplete Guide to Its Use and Abuse, the former of which I highly recommend for its excellent historical treatment of Alan Turing's original 36-page paper establishing what is now known as the Turing Machine, and the latter book whose mathematical & philosophical topic arguably spurred the development of the former (for a short & neat explanation of this for the layman, ).

I usually like accompanying my studies with historical background like this to not only help motivate me, but also to give me a bigger "forest-over-trees" picture and context as to why these ideas were even formed to begin with, how this fits into the grander historical narrative, and why I should even care. It's also somewhat fun for my socially-inclined primate brain to know the people and controversies behind such ideas, which provides a useful scaffold and cognitive framework to remember this material much better and for longer (if you especially enjoy this, see the book Exact Thinking in Demented Times: The Vienna Circle and the Epic Quest for the Foundations of Science).

In addition to the aforementioned books, I would also recommend going through which covers the Theory of Computing and solves a lot of practice problems with you (the latter of which is key to becoming fluent with this material!) Furthermore, you can also download all the Python and Java code for this course . Hopefully all that linked material proves helpful on your learning journey :)

Content
Somewhat similar to Sipser's book and similar to most "Theory of Computation" curricula, this book is broken up into 2 main parts: Computability Theory and Complexity Theory.

In the first section of this book we go over what can and cannot be computed by a program (using Python programs as examples), as well as some impossible Python programs. The Halting problem and proof by contradiction was smartly done here using practical examples. We then go over various computational problems, beginning with graphs, alphabets, strings, and languages, the different categories of problems (search, optimization, threshold, function, decision, etc), recognizing vs. deciding languages, and then finally the model of a Turing machine. I really think this latter part is how college courses should be teaching this material and I wish my official university course did something similar. Oftentimes it is very time consuming to draw Turing machines and then when it gets more complicated students are often forced to write pseudo-code and line-by-line high-level versions of algorithms on paper. Using this author's approach of writing tangible Python programs I think is quite superior in pedagogical strategy as there are multiple ways students can experiment, play, and "check" their programs in real-time, which grants much more intuition than something like an algorithm written on paper that can only really be "checked" for correctness once it's turned-in to an external grader/teacher and then handed back. The feedback loop for learning is just too wide and sometimes non-existent for the latter to really have a strong effect on one's learning. It is because of this that I think a book like this should be praised quite highly for moving the education field forward.

Going back to the material, after variations of Turing machines and then introduction to universal Turing machines, we then are taught the technique of reductions (for an interesting article on "time-traveling Turing machines" and closed-timelike curves in computation, by quantum computing theorist, Scott Aaronson). As we can see, compared to the Sipser book this book explains how the reduction technique in proofs works visually:



And here:



This is then followed up with nondeterminism, and finally DFAs and NFAs, regular expressions, and our famous pumping lemma. Here is where we can note the "flip-flop" order of this book compared to a more traditional curriculum which usually starts off with this material. Somewhat of an aside, but I really wished this book at least introduced or covered a little bit of context-sensitive grammars, since that was my primary interest and motivation for even taking this course to begin with (due to its relationship with cellular automata, lindenmayer systems, artificial life, and theoretical biology, all of which ). None of the books I have encountered so far even do this! Gah!

The book then moves on to the second half of the material concerning computational complexity theory, moving away from asking questions about "possibility" and more towards questions of "efficiency". Big-O notation is introduced, in addition to your usual complexity classes. Further depth is then achieved in the next section with the reader delving into polynomial and exponential complexities, with the next two sections covering polynomial-time mapping reductions and NP-completeness, with a nice diagram showing the polyreductions used in this book:



I believe this is where an author's more practical strategy of teaching through code shines here, as this allows one to actually see where these problems apply in their daily workplace settings or even maybe another course they might take in the future such as in cryptography, networking, or algorithms. The book concludes with more history and theoretically-bent material with the famous Church-Turing thesis, undecidability of Peano arithmetic, Karp's problems and reductions, etc.

Conclusion
Overall, this book introduced highly fascinating material at the intersection of multiple disciplines of computer science, logic, math, philosophy, electrical engineering, linguistics, etc. The amount of accompanying explanatory discussion along with the very practically-minded approach via Python programs makes this book highly recommended in my opinion, especially for self-study.

My only comment for improvement is to include some introductory material in the computability section on *context-sensitive grammars! I would've loved to have an official and well-backed source that I could reference and learn this from (especially since I haven't yet come across a theory of computing book that does just that). And also, although it might seem a tad too advanced, I do think maybe a brief introduction to what is known as which observes the fundamental relationships between computation / programming languages, formal logic / type theory, and category theory / topology to be a highly relevant and significant perspective which would allow the student coming from another field to see all the fascinating connections linking everything together, or alternatively help a student to branch out to other fields to which the theory of computation can be applied. This "Rosetta stone" is a marvelous way to bring this book and field to higher prominence and relevance today. I know this book is aimed towards undergrads, but I think if the author chose to incorporate just these two aforementioned materials they would probably usurp the Sipser book's reign on Theory of Computing curricula!

Thanks for reading :)

*EDIT: From the comments below with Ritu, I was motivated to take a look at the textbook Automata, Computability and Complexity: Theory and Applications by Elaine Rich and just found out that by way of the Myhill–Landweber–Kuroda theorem! So technically to be fair, I guess the above textbook by MacCormick indirectly covered CSGs whether the author intended to or not.
]]> 145058 556 Dan Gusfield 0521585198 Mundy 0 4.08 1997
author: Dan Gusfield
name: Mundy
average rating: 4.08
book published: 1997
rating: 0
read at:
date added: 2021/11/02
shelves: to-read, computer-science, algorithms, discrete-math, mathematics, biology
review:

]]> 7506516 496 Erik D. Demaine 0521715229 Mundy 0 4.28 2007
author: Erik D. Demaine
name: Mundy
average rating: 4.28
book published: 2007
rating: 0
read at:
date added: 2021/11/02
shelves: to-read, algorithms, art, computer-science, geometry, mathematics
review:

]]> 12390341 59 Scott Aaronson Mundy 5 4.35
author: Scott Aaronson
name: Mundy
average rating: 4.35
book published:
rating: 5
read at: 2021/02/20
date added: 2021/11/02
shelves: algorithms, complexity-theory, cognitive-science, computer-science, philosophy, philosophy-of-math
review:

]]> 558070
* A new chapter on recurrent iterated function systems, including vector recurrent iterated function systems.* Problems and tools emphasizing fractal applciations.* An all-new answer key to problems in the text, with solutions and hints.]]> 552 Michael F. Barnsley 0120790696 Mundy 0 4.15 1988
author: Michael F. Barnsley
name: Mundy
average rating: 4.15
book published: 1988
rating: 0
read at:
date added: 2021/10/23
shelves: artificial-life, computer-science, complexity-theory, discrete-math, generative_art, geometry, mathematics, algorithms, biology
review:

]]> 1061734 Wolfgang Banzhaf 155860510X Mundy 0 3.83 1997
author: Wolfgang Banzhaf
name: Mundy
average rating: 3.83
book published: 1997
rating: 0
read at:
date added: 2021/09/23
shelves: to-read, artificial-life, algorithms, computer-science, complexity-theory, genetics
review:

]]> 5241622 504 Yoav Shoham 0521899435 Mundy 0 3.75 2008
author: Yoav Shoham
name: Mundy
average rating: 3.75
book published: 2008
rating: 0
read at:
date added: 2021/09/17
shelves: to-read, computer-science, economics, algorithms, game-theory, logic, mathematics, philosophy, social-sciences, linguistics, psychology
review:

]]> 46126303 488 Andreas Deutsch 1489979808 Mundy 0 0.0
author: Andreas Deutsch
name: Mundy
average rating: 0.0
book published:
rating: 0
read at:
date added: 2021/08/06
shelves: artificial-life, biology, algorithms, computer-science, complexity-theory
review:

]]> 34867272
The book inspires artists to take on cellular automata as a tool of creativity and it persuades scientists to convert their research results into the works of art.



The book is lavishly illustrated with visually attractive examples, presented in a lively and easily accessible manner.]]> 281 Andrew Adamatzky 3319272705 Mundy 0 4.00
author: Andrew Adamatzky
name: Mundy
average rating: 4.00
book published:
rating: 0
read at:
date added: 2021/08/06
shelves: to-read, algorithms, artificial-life, art, biology, complexity-theory, computer-science, generative_art
review:

]]> 16123828 520 Daniel Shiffman 0985930802 Mundy 0 4.60 2012
author: Daniel Shiffman
name: Mundy
average rating: 4.60
book published: 2012
rating: 0
read at:
date added: 2021/08/06
shelves: to-read, generative_art, algorithms, art, computer-science
review:

]]> 45152739
Linear optimization is a powerful modeling method for discovering the best solution to a problem among a set of available alternatives. It is one of today’s most important branches of mathematics and computer science―and also a surprisingly rich medium for creating breathtaking works of art. Opt Art takes readers on an entertaining tour of linear optimization and its applications, showing along the way how it can be used to design visual art.

Robert Bosch provides a lively and accessible introduction to the geometric, algebraic, and algorithmic foundations of optimization. He presents classical applications, such as the legendary Traveling Salesman Problem, and shows how to adapt them to make optimization art―opt art. Each chapter in this marvelously illustrated book begins with a problem or puzzle and demonstrates how the solution can be derived using a host of artistic methods and media, including 3D printing, laser cutting, and computer-controlled machining. Bosch focuses on mathematical modeling throughout―converting a problem into a workable mathematical form, solving it using optimization techniques, and examining the results, which can take the form of mosaics, line drawings, and even sculpture. All you need is some high-school algebra, geometry, and calculus to follow along.

Featuring more than a hundred illustrations and photos of Bosch’s own art, Opt Art demonstrates how mathematics and computing can be used to create beauty and express emotion through amazing works of art.]]> 200 Robert Bosch 0691164061 Mundy 0 4.53
author: Robert Bosch
name: Mundy
average rating: 4.53
book published:
rating: 0
read at:
date added: 2021/08/02
shelves: to-read, art, algorithms, computer-science, mathematics
review:

]]> 13839366 504 Michael Sipser 113318779X Mundy 5 Motivation
If you've never heard of why someone would study the "Theory of Computation" and how this differs from something perhaps more tangible like programming or software engineering, you might come to the conclusion that this is "all just theory"...*waves around hand in the air in a useless circular manner*, but I'd beg you to not jump to this thought too soon! It's not that the latter is practical, while the former is just theory, but rather that what we call "programming" or "software engineering" is usually very specific to a certain set of technologies of a specific era or even a specific hardware implementation, whereas the former "theory" contains concepts that can be applied agnostic of the hardware you are dealing with, agnostic to the time period you are living in, agnostic of the specific programming language you are using, and even in my case, agnostic to the field at which you are even applying this knowledge to!

Computing is a very general concept that can be applied to multiple fields and domains of expertise and is much more a "way of thinking" and collection of unique logical tools and methods for solving problems in whatever domain, either software, linguistics, mathematics, electrical engineering, philosophy, botany, physics, and in my case, the foundations of biology! It is kind of unfortunate given the name, but "computing" is not about computers per se, but rather about the nature of problem solving, talking about certain limits to how efficiently a problem can be solved, and even figuring out if our problem even has a way of solving it to begin with (which you'll come to learn is very different from merely checking whether an answer is correct)! The nature of time, memory, space, efficiency, and representation are all topics that are explored in this area.

Background
Having just recently finished a Formal Grammars & Automata Theory course at the local university where we used this as our textbook, I have to say that this book was probably the main reason for why I was able to keep up and not fall behind in the course. It doesn't read like a dry definition-lemma-proof book you might have encountered in some fields of math, but rather a hybrid of that with lots of helpful injected commentary going over the thought processes of how to solve these problems and how to work your way through these proofs in plain old regular english, with lots of useful diagrams when needed. One thing I especially appreciated was the author giving a theorem or making a claim, then following that up with a helpful discussion on the "proof idea" behind that claim, and then next with the proof written in a combination of english + symbols, and finally if needed, a very formal "algorithmic" way with the steps clearly enumerated line-by-line and in concise fashion.

An example of that can be seen here:


This is a really good pedagogical technique that I wish more authors would follow, as students are given a choice as to "what level" of explanation and rigor best appeals to them. Here's another example, this time with an accompanying picture:


For the self-study people out there thinking about prerequisites, it would probably be wise to have some practice and former experience with "proofs", but regardless, the author does a great job reviewing common mathematical notation and basic proof techniques at the beginning of the book, which would usually correspond to your common undergraduate first course in discrete mathematics. Such things as relations, functions, graphs, strings, languages, boolean logic, proof by construction / contradiction / induction, etc are reviewed at the beginning and accompanied with ample practice problems (with solutions!) such that you can strengthen your foundation if needed before moving onto the meat of the book. As a disclaimer, although I'm just a data scientist with a former background in neuroscience, I have invested a non-trivial amount of both non-formal + official time in coursework such as logic, set theory, and generally "pure math" areas, and I was also concurrently going through another official and very complementary logic course in Undecidability & Incompleteness, so take my review with that in mind.

Other Helpful Material
When studying some subject I always recommend trying to learn from multiple sources because you can't always guarantee that you'll never "get stuck" on some concept or section of a book. I've found that sometimes having multiple perspectives and different people explaining things to me can help. As such, I supplemented my reading with another textbook called What Can Be Computed? (my review here) which gives a more *hands-on*, practical approach to the theory of computing with lots of exercises in Python.

Two other books I was reading in parallel that I recommend are The Annotated Turing and Gödel's Theorem: An Incomplete Guide to Its Use and Abuse, the former of which I highly recommend for its excellent historical treatment of Alan Turing's original 36-page paper establishing what is now known as the Turing Machine, and the latter book whose mathematical & philosophical topic arguably spurred the development of the former (for a short & neat explanation of this for the layman, ). I usually like accompanying my studies with historical background like this to not only help motivate me, but also to give me a bigger "forest-over-trees" picture and context as to why these ideas were even formed to begin with, how this fits into the grander historical narrative, and why I should even care. It's also somewhat fun for my socially-inclined primate brain to know the people and controversies behind such ideas, which provides a useful scaffold and cognitive framework to remember this material much better and for longer (if you especially enjoy this, see the book Exact Thinking in Demented Times: The Vienna Circle and the Epic Quest for the Foundations of Science).

In addition to the aforementioned books, I would also recommend going through which covers the Theory of Computing and solves a lot of practice problems with you (the latter of which is key to becoming fluent with this material!) Hopefully all that linked material proves helpful on your learning journey :)

Content
This book is broken up into 3 main parts: Automata & Languages, Computability Theory, and Complexity Theory. Again, each section contains lots of worked out examples with solutions, accompanied with helpful commentary.

The first part was my favorite and the main reason for why I was taking this course. In it the author covers the theory of regular languages, going over finite automata, non-determinism, regular expressions, and non-regular languages, while introducing you to a new and useful proof technique called the Pumping Lemma, which allows you to disprove the regularity of a language. For those coming from a linguistics background, you might find the intersection of this material and the incredibly fascinating. The author then follows this up with material about context-free languages, discussing context-free grammars, pushdown automata, non-context free languages, and deterministic context-free languages. This material is highly relevant to those who are interested in the more practical problems of parsing natural languages, or maybe designing your own programming language, or even how a compiler works, etc. Somewhat of an aside, but I really wished this book at least introduced or covered a little bit of context-sensitive grammars, since that was my primary interest and motivation for even taking this course to begin with (due to its relationship with cellular automata, lindenmayer systems, artificial life, and theoretical biology, all of which ).

In the second part of this book, the content shifts focus towards arguably more historical and philosophical content going under the header of 'Computability Theory'. Here we are introduced to the famous Church-Turing Thesis, Turing machines and a few of their variants (for an interesting article on "time-traveling Turing machines" and closed-timelike curves in computation, by quantum computing theorist, Scott Aaronson). This section also covers the famous Halting/Decidability problem, as well as important proof techniques like diagonalization and reducibility. Some advanced topics are also covered with a small introduction to information theory and minimal length description, the compressibility of strings, randomness, etc. Although we didn't officially cover it in my course, I found this latter section quite interesting! (and especially relevant to biology!)

This last section of the book switches gears to what arguably makes up the bulk of most theoretical computer science research today. It deals with something called 'Complexity Theory'. Whereas the former second section of the book dealt with the question of whether some problems were even possible to solve to begin with, this latter third section of the book deals with how efficient can a problem be solved given a certain amount of time, space, memory, etc, ranking problems according to certain complexity classes. In here we first are introduced to how we measure complexity using Big-O notation, the famous P vs NP problem, NP-completeness, the Cook-Levin Theorem, SAT problems, and additional NP-complete problems like independent set, vertex cover, hamiltonian path, subset-sum, etc (which are all helpful in proof techniques like reduction used to prove NP-completeness, etc). And although we never were able to cover this far in my official course, the book does continue to go over space complexity like Savitch's theorem, NL-completeness, Intractability (hierarchy problems, relativization, and circuit complexity), as well as more advanced topics like approximation algorithms, probabilistic algorithms interactive proof systems, parallel computation, and cryptography, all of which I assume the author included in case this book is used in the graduate-level Masters or PhD setting for specific topical courses and such.

Conclusion
Overall, this book introduced highly fascinating material at the intersection of multiple disciplines of computer science, logic, math, philosophy, electrical engineering, linguistics, etc. The amount of accompanying explanatory discussion along with the ample amount of worked-out examples makes this book highly recommended in my opinion (and suitable for self-study, especially if you follow along with one of the free lecture materials I linked to above).

My only comment for improvement is to include some introductory material in the first section on *context-sensitive grammars! I would've loved to have an official and well-backed source that I could reference and learn this from. And also, although it might seem a tad too advanced, I do think maybe a brief introduction to what is known as which observes the fundamental relationships between computation / programming languages, formal logic / type theory, and category theory / topology to be a highly relevant and significant perspective which would allow the student coming from another field to see all the fascinating connections linking everything together, or alternatively help a student to branch out to other fields to which the theory of computation can be applied. This "rosetta stone" is a marvelous way to bring this book and field to higher prominence and relevance today.

Thank you for reading :)

*EDIT: From the comments on another book review with Ritu, I was motivated to take a look at the textbook Automata, Computability and Complexity: Theory and Applications by Elaine Rich and just found out that by way of the Myhill–Landweber–Kuroda theorem! So technically to be fair, I guess the above textbook by Sipser indirectly covered CSGs whether the author intended to or not.]]> 4.28 1996
author: Michael Sipser
name: Mundy
average rating: 4.28
book published: 1996
rating: 5
read at: 2021/06/11
date added: 2021/06/19
shelves: complexity-theory, computer-science, highly-regarded, linguistics, mathematics, philosophy, logic, discrete-math, formal-grammars, algorithms
review:
Motivation
If you've never heard of why someone would study the "Theory of Computation" and how this differs from something perhaps more tangible like programming or software engineering, you might come to the conclusion that this is "all just theory"...*waves around hand in the air in a useless circular manner*, but I'd beg you to not jump to this thought too soon! It's not that the latter is practical, while the former is just theory, but rather that what we call "programming" or "software engineering" is usually very specific to a certain set of technologies of a specific era or even a specific hardware implementation, whereas the former "theory" contains concepts that can be applied agnostic of the hardware you are dealing with, agnostic to the time period you are living in, agnostic of the specific programming language you are using, and even in my case, agnostic to the field at which you are even applying this knowledge to!

Computing is a very general concept that can be applied to multiple fields and domains of expertise and is much more a "way of thinking" and collection of unique logical tools and methods for solving problems in whatever domain, either software, linguistics, mathematics, electrical engineering, philosophy, botany, physics, and in my case, the foundations of biology! It is kind of unfortunate given the name, but "computing" is not about computers per se, but rather about the nature of problem solving, talking about certain limits to how efficiently a problem can be solved, and even figuring out if our problem even has a way of solving it to begin with (which you'll come to learn is very different from merely checking whether an answer is correct)! The nature of time, memory, space, efficiency, and representation are all topics that are explored in this area.

Background
Having just recently finished a Formal Grammars & Automata Theory course at the local university where we used this as our textbook, I have to say that this book was probably the main reason for why I was able to keep up and not fall behind in the course. It doesn't read like a dry definition-lemma-proof book you might have encountered in some fields of math, but rather a hybrid of that with lots of helpful injected commentary going over the thought processes of how to solve these problems and how to work your way through these proofs in plain old regular english, with lots of useful diagrams when needed. One thing I especially appreciated was the author giving a theorem or making a claim, then following that up with a helpful discussion on the "proof idea" behind that claim, and then next with the proof written in a combination of english + symbols, and finally if needed, a very formal "algorithmic" way with the steps clearly enumerated line-by-line and in concise fashion.

An example of that can be seen here:


This is a really good pedagogical technique that I wish more authors would follow, as students are given a choice as to "what level" of explanation and rigor best appeals to them. Here's another example, this time with an accompanying picture:


For the self-study people out there thinking about prerequisites, it would probably be wise to have some practice and former experience with "proofs", but regardless, the author does a great job reviewing common mathematical notation and basic proof techniques at the beginning of the book, which would usually correspond to your common undergraduate first course in discrete mathematics. Such things as relations, functions, graphs, strings, languages, boolean logic, proof by construction / contradiction / induction, etc are reviewed at the beginning and accompanied with ample practice problems (with solutions!) such that you can strengthen your foundation if needed before moving onto the meat of the book. As a disclaimer, although I'm just a data scientist with a former background in neuroscience, I have invested a non-trivial amount of both non-formal + official time in coursework such as logic, set theory, and generally "pure math" areas, and I was also concurrently going through another official and very complementary logic course in Undecidability & Incompleteness, so take my review with that in mind.

Other Helpful Material
When studying some subject I always recommend trying to learn from multiple sources because you can't always guarantee that you'll never "get stuck" on some concept or section of a book. I've found that sometimes having multiple perspectives and different people explaining things to me can help. As such, I supplemented my reading with another textbook called What Can Be Computed? (my review here) which gives a more *hands-on*, practical approach to the theory of computing with lots of exercises in Python.

Two other books I was reading in parallel that I recommend are The Annotated Turing and Gödel's Theorem: An Incomplete Guide to Its Use and Abuse, the former of which I highly recommend for its excellent historical treatment of Alan Turing's original 36-page paper establishing what is now known as the Turing Machine, and the latter book whose mathematical & philosophical topic arguably spurred the development of the former (for a short & neat explanation of this for the layman, ). I usually like accompanying my studies with historical background like this to not only help motivate me, but also to give me a bigger "forest-over-trees" picture and context as to why these ideas were even formed to begin with, how this fits into the grander historical narrative, and why I should even care. It's also somewhat fun for my socially-inclined primate brain to know the people and controversies behind such ideas, which provides a useful scaffold and cognitive framework to remember this material much better and for longer (if you especially enjoy this, see the book Exact Thinking in Demented Times: The Vienna Circle and the Epic Quest for the Foundations of Science).

In addition to the aforementioned books, I would also recommend going through which covers the Theory of Computing and solves a lot of practice problems with you (the latter of which is key to becoming fluent with this material!) Hopefully all that linked material proves helpful on your learning journey :)

Content
This book is broken up into 3 main parts: Automata & Languages, Computability Theory, and Complexity Theory. Again, each section contains lots of worked out examples with solutions, accompanied with helpful commentary.

The first part was my favorite and the main reason for why I was taking this course. In it the author covers the theory of regular languages, going over finite automata, non-determinism, regular expressions, and non-regular languages, while introducing you to a new and useful proof technique called the Pumping Lemma, which allows you to disprove the regularity of a language. For those coming from a linguistics background, you might find the intersection of this material and the incredibly fascinating. The author then follows this up with material about context-free languages, discussing context-free grammars, pushdown automata, non-context free languages, and deterministic context-free languages. This material is highly relevant to those who are interested in the more practical problems of parsing natural languages, or maybe designing your own programming language, or even how a compiler works, etc. Somewhat of an aside, but I really wished this book at least introduced or covered a little bit of context-sensitive grammars, since that was my primary interest and motivation for even taking this course to begin with (due to its relationship with cellular automata, lindenmayer systems, artificial life, and theoretical biology, all of which ).

In the second part of this book, the content shifts focus towards arguably more historical and philosophical content going under the header of 'Computability Theory'. Here we are introduced to the famous Church-Turing Thesis, Turing machines and a few of their variants (for an interesting article on "time-traveling Turing machines" and closed-timelike curves in computation, by quantum computing theorist, Scott Aaronson). This section also covers the famous Halting/Decidability problem, as well as important proof techniques like diagonalization and reducibility. Some advanced topics are also covered with a small introduction to information theory and minimal length description, the compressibility of strings, randomness, etc. Although we didn't officially cover it in my course, I found this latter section quite interesting! (and especially relevant to biology!)

This last section of the book switches gears to what arguably makes up the bulk of most theoretical computer science research today. It deals with something called 'Complexity Theory'. Whereas the former second section of the book dealt with the question of whether some problems were even possible to solve to begin with, this latter third section of the book deals with how efficient can a problem be solved given a certain amount of time, space, memory, etc, ranking problems according to certain complexity classes. In here we first are introduced to how we measure complexity using Big-O notation, the famous P vs NP problem, NP-completeness, the Cook-Levin Theorem, SAT problems, and additional NP-complete problems like independent set, vertex cover, hamiltonian path, subset-sum, etc (which are all helpful in proof techniques like reduction used to prove NP-completeness, etc). And although we never were able to cover this far in my official course, the book does continue to go over space complexity like Savitch's theorem, NL-completeness, Intractability (hierarchy problems, relativization, and circuit complexity), as well as more advanced topics like approximation algorithms, probabilistic algorithms interactive proof systems, parallel computation, and cryptography, all of which I assume the author included in case this book is used in the graduate-level Masters or PhD setting for specific topical courses and such.

Conclusion
Overall, this book introduced highly fascinating material at the intersection of multiple disciplines of computer science, logic, math, philosophy, electrical engineering, linguistics, etc. The amount of accompanying explanatory discussion along with the ample amount of worked-out examples makes this book highly recommended in my opinion (and suitable for self-study, especially if you follow along with one of the free lecture materials I linked to above).

My only comment for improvement is to include some introductory material in the first section on *context-sensitive grammars! I would've loved to have an official and well-backed source that I could reference and learn this from. And also, although it might seem a tad too advanced, I do think maybe a brief introduction to what is known as which observes the fundamental relationships between computation / programming languages, formal logic / type theory, and category theory / topology to be a highly relevant and significant perspective which would allow the student coming from another field to see all the fascinating connections linking everything together, or alternatively help a student to branch out to other fields to which the theory of computation can be applied. This "rosetta stone" is a marvelous way to bring this book and field to higher prominence and relevance today.

Thank you for reading :)

*EDIT: From the comments on another book review with Ritu, I was motivated to take a look at the textbook Automata, Computability and Complexity: Theory and Applications by Elaine Rich and just found out that by way of the Myhill–Landweber–Kuroda theorem! So technically to be fair, I guess the above textbook by Sipser indirectly covered CSGs whether the author intended to or not.
]]> 8250182
The book opens with an introduction to computer programming. Each of twelve subsequent chapters presents a different modeling paradigm by describing its basic structure and showing how it can be applied in understanding brain function. The text guides the reader through short, simple computer programs--printed in the book and available by download at the companion website--that implement the paradigms and simulate real neural systems. Motivation for the simulations is provided in the form of a narrative that places specific aspects of neural system behavior in the context of more general brain function. The narrative integrates instruction for using the programs with description of neural system function, and readers can actively experience the fun and excitement of doing the simulations themselves. Designed as a hands-on tutorial for students, this book also serves instructors as both a teaching tool and a source of examples and exercises that provide convenient starting points for
more in-depth exploration of topics of their own specific interest.

The distinguishing pedagogical feature of this book is its computer programs, written in MATLAB, that help readers develop basic skill in the area of neural systems modeling. (All of the program files are available online via the book's companion website.) Actual data on real neural systems is presented in the book for comparison with the results of the simulations. Also included are asides ("Math Boxes") that present mathematical material that is relevant but not essential to running the programs. Exercises and references at the end of each chapter invite readers to explore each topic area on their own.]]> 542 Thomas J. Anastasio 0878933395 Mundy 5 4.58 2009
author: Thomas J. Anastasio
name: Mundy
average rating: 4.58
book published: 2009
rating: 5
read at: 2013/12/31
date added: 2021/06/15
shelves: algorithms, neuroscience, deep-learning, computer-science, biology, cognitive-science, psychology
review:

]]> 22847284
Grokking Algorithms is a disarming take on a core computer science topic. In it, you'll learn how to apply common algorithms to the practical problems you face in day-to-day life as a programmer. You'll start with problems like sorting and searching. As you build up your skills in thinking algorithmically, you'll tackle more complex concerns such as data compression or artificial intelligence. Whether you're writing business software, video games, mobile apps, or system utilities, you'll learn algorithmic techniques for solving problems that you thought were out of your grasp. For example, you'll be able to:
Write a spell checker using graph algorithms
Understand how data compression works using Huffman coding
Identify problems that take too long to solve with naive algorithms, and attack them with algorithms that give you an approximate answer instead
Each carefully-presented example includes helpful diagrams and fully-annotated code samples in Python. By the end of this book, you will know some of the most widely applicable algorithms as well as how and when to use them.]]> 256 Aditya Y. Bhargava 1617292230 Mundy 4 4.41 2015
author: Aditya Y. Bhargava
name: Mundy
average rating: 4.41
book published: 2015
rating: 4
read at: 2018/01/12
date added: 2021/06/15
shelves: computer-science, interview-prep, algorithms
review:

]]> 25666050 A fascinating exploration of how insights from computer algorithms can be applied to our everyday lives, helping to solve common decision-making problems and illuminate the workings of the human mind

All our lives are constrained by limited space and time, limits that give rise to a particular set of problems. What should we do, or leave undone, in a day or a lifetime? How much messiness should we accept? What balance of new activities and familiar favorites is the most fulfilling? These may seem like uniquely human quandaries, but they are not: computers, too, face the same constraints, so computer scientists have been grappling with their version of such issues for decades. And the solutions they've found have much to teach us.

In a dazzlingly interdisciplinary work, acclaimed author Brian Christian and cognitive scientist Tom Griffiths show how the algorithms used by computers can also untangle very human questions. They explain how to have better hunches and when to leave things to chance, how to deal with overwhelming choices and how best to connect with others. From finding a spouse to finding a parking spot, from organizing one's inbox to understanding the workings of memory, Algorithms to Live By transforms the wisdom of computer science into strategies for human living.]]> 368 Brian Christian 1627790365 Mundy 5 4.12 2016
author: Brian Christian
name: Mundy
average rating: 4.12
book published: 2016
rating: 5
read at: 2016/05/01
date added: 2021/06/15
shelves: computer-science, cognitive-science, highly-regarded, algorithms
review:

]]> 17558445 438 Bradley N. Miller 1590282574 Mundy 5 4.25 2005
author: Bradley N. Miller
name: Mundy
average rating: 4.25
book published: 2005
rating: 5
read at: 2020/05/25
date added: 2021/06/15
shelves: computer-science, references, python, interview-prep, algorithms
review:

]]>