This book is really excellent if you're into metaheuristics and natural algorithms. A great deal of my graduate computer science research was in thisThis book is really excellent if you're into metaheuristics and natural algorithms. A great deal of my graduate computer science research was in this field and I have dozens and dozens of books on the subject, but this is by far my favorite.

Jason Brownlee neatly categorizes most of the well-known metaheustics and nature-inspired algorithms and, for each one, explains how it works, why it works, when to use it, and even provides working examples written in Ruby. This might simply be bias talking but Ruby is one of my favorite programming languages so I found all of the code supplementing the usual pseudocode extremely helpful.

This book made sense of a ton of different metaheuristic algorithms for me, I used it constantly in my research. If you're interested in the subject, I recommend reading it as follows: read all of Part 1 (Background), then read the Overview sections on each chapter in Part II (Algorithms). I don't recommend trying to read straight through, the book is really more of a reference book. Each algorithm is generally self-contained, so you can just read what you need. If you want a broader understanding, read each algorithm's Inspiration, Metaphor, and Strategy sections as well, and the Heuristics sections when applicable (they cover when you would and wouldn't use it). My first attempt at this book was a front-to-back reading because I knew I was doing so much research in this area, but ultimately I think this wasn't the right approach for the book. It's a desk reference above all else.

This book isn't as math-y or proof-y as a lot of similar books (looking at you Handbook of Approximation Algorithms and Metaheuristics), it's far more practical with it's code samples in pesudocode and Ruby. This is really intended for practitioners who want to solve problems using nature-inspired algorithms, I don't think it's really intended for people who want to make contributions to the field of metaheuristics in general (though there is a section in Part III about designing your own algorithms).

All in all, great book, exactly what I was looking for and very helpful in my studies....more

My white whale. I insisted I read this book cover to cover, and it took me much longer than I originally planned, I was so excited when I finally finiMy white whale. I insisted I read this book cover to cover, and it took me much longer than I originally planned, I was so excited when I finally finished it.

This was the perfect book at the perfect time for me. I'm working on my PhD, and my primary areas of interest for research are things like approximation algorithms, metaheuristics, and the like. This is a pretty wide net, and I wasn't familiar with everything in it, but I needed to understand a lot of background material. I couldn't even really read papers because, one, there would be too many to read, two, it would be too hard to find the "originals" for any given topic, and three, I lacked enough background material that I could barely understand a lot of the papers anyway.

As I was trying to narrow down my research topic, I was beginning to feel overwhelmed, drowning in a sea of information, and ill-equipped to swim to shore myself. Then I discovered this book, which distilled the entire huge area into a single volume. Covering not only the basics, but the current (as of 2004) state of things as well. It was the exact book I needed, and I'm incredibly glad someone wrote it.

The book is very well-written. It's clearly intended for students, in fact the author even claims its for undergraduate students (I was never exposed to this kind of stuff as an undergrad). I think it suffers from the problem that a lot of computer science textbooks suffer from, which is a general overreliance on notation to convey ideas. Missing or misremembering what a particular mathematical symbol or letter stands for makes it difficult to understand, and I generally prefer when texts, especially those written for students, provide prose explanations immediately before or after a section of heavy notation. Algorithmics for Hard Problems does a semi-decent job of this, but more often than not relies on pure notation.

The main reason I docked this otherwise excellent book by a star is it does a thing that I find more and more computer science textbooks doing when they are "overview" style books, meaning that they cover a wide selection of material rather than diving deep into a few specific things. I call it "Chapter 0", largely because many of these books also refer to it as Chapter 0. It's a single, extremely long chapter at the beginning of the book providing all of the "background material" for the rest of the book. Definitions, terms, notation, problem definitions and abbreviations, whatever the author(s) do not feel like discussing in the book proper, it just gets crammed in here. I hate Chapter 0. Reading Chapter 0 from beginning to end is a non-starter for any student wanting to learn from the book, because it's pages upon pages (in this case, 134 pages) of material not directly relevant to the topic of the book, which is insanely boring. Moreover, it's impossible to remember so much densely packed information, so reading it isn't even terribly useful. Instead then, readers (like me) will skip this chapter and begin reading once the actual book starts. But then, you're immediately confronted with notation and terminology you don't understand. This forces you to flip to the index, try to find the first occurence of the thing, flip back to Chapter 0 in the right place, and read up. A section heavy with this kind of thing will require flipping between pages dozens upon dozens of times, it's extremely irritating.

What I would prefer is for Chapter 0 to be spread throughout the book. Eliminate it. Then, the first time in the book something is referenced which would be in Chapter 0, instead create a sidebar-style box giving the background information right then and there. Readers familiar with it already can skip right over because it is visually distinctive, but other readers can have it explained right there where they need it. At the very least, if you're going to have a Chapter 0, directly reference page numbers as a footnote or a parenthetical when material from it is referenced in the book proper, to avoid the index-search. Many textbooks do this, so I can't blame this book too much because it's something of a standard, but I still hate it and won't give a book 5 stars if it does it.

Otherwise, this book is excellent, extremely informative and well-written. If you're into this material, I'd say that "Handbook of Approximation Algorithms" is actually a bit better-written, in the sense that it's very, very conversational and aimed at students, but that this book is much shorter and a bit less holistic, and therefore a better "cover-to-cover" book (whereas Handbook is a better reference in a lot of ways)....more

This is a thin but very focused Graph Theory book, which is good. Rather than Graph Theory being simply some part of a larger book on theory or algoriThis is a thin but very focused Graph Theory book, which is good. Rather than Graph Theory being simply some part of a larger book on theory or algorithms, having a thin but focused book on graphs lends itself well to being a textbook for a devoted graph theory course. There are a few similar books, but not tons.

I realize it's part of the title, but frankly I found the book to be too Problem-Oriented. Sections contained very little explanatory text, almost of all of the "learning" is done not through explanation, but by doing problems. I think textbooks should have a good selection of problems, but I think this book skews too much in favor of the approach. Without answers in the book, it's very possible to read the book and simply not understand a great deal of graph theory material. There's no way to check that you're learning correctly, and there's no way to double-check your understanding.

Marcus's book is good, and the explanations provided are clear and well-organized, but too often a reader will have questions about material that would be best answered by the books authors, but must instead be answered by the reader him or herself....more

Elaine Rich's Automata, Computability, and Complexity book is, to me, the CLRS of automata theory. CLRS never goes terribly deep into it's algorithms,Elaine Rich's Automata, Computability, and Complexity book is, to me, the CLRS of automata theory. CLRS never goes terribly deep into it's algorithms, but it provides an extremely wide breadth of material backed by solid explanations and clear prose.

While the Sipser book probably remains my favorite book on Theory and Automata, Rich's book definitely covers more, and definitely covers it at a slower pace, making sure not to lose students. Sipser's book is excellent as long as you can follow along, but if something comes along that doesn't make sense to you, the book offers you no assistance. Rich, on the other hand, takes more time to explain things to make sure they are clear. As a result of this slower pace and wider variety of material, Rich's book is certainly larger and more intimidating.

I think Rich's book makes for a better desk reference than a tutorial (like CLRS), though I have to note that Rich's writing style is excellent and clear, so it doesn't make for a poor tutorial text at all. Rich covers lots of complexity-related topics that Sipser barely mentions as well, so this book makes a great reference for basic complexity theory.

One complaint is that it, like Sipser and most other Theory and Automata books, introduces FSM and PDA before Turing machines. I acknowledge that this is more or less the standard order for academica, but I strongly feel that introducing TMs and computability/noncomputability first helps frame an understanding of regular languages and context-free languages that makes them more approachable and interesting. I can't really fault this book for doing what everyone else does, but I felt I had to mention it.

All in all, this is an excellent, expertly-written desk reference for Automata/Theory, and I highly recommend it to anyone interested in CS theory....more

As a Computer Science PhD candidate, I was absolutely shocked to see a book like this even exists - it seems so specific, but writing inIndispensable.

As a Computer Science PhD candidate, I was absolutely shocked to see a book like this even exists - it seems so specific, but writing in the Computer Science field is often terrible, and Justin Zobel's book painlessly dissects what makes CS papers so bad, and how to avoid those problems.

The book covers everything, ranging from how to conduct research to how to perform experiments, and, of course, how to actually write the paper. No stone is left unturned, Zobel doles out advice for grammar as well as figure and table design, software to use, bibliographies, and how to best structure a paper to effectively communicate ideas. He even includes sections on ethics, giving presentations, and refereeing papers.

Most of the book consists of an explanation of how to write effectively in Computer Science, followed by one or more examples of how to fail in that specific way, followed by an example of how to succeed. These comparisons make it very easy to understand Zobel's points, so the book is very easy to digest and understand.

If you're in Computer Science, and you're writing papers with the goal of publishing, this is an absolute must-read, end of story.

The only bad thing I can say about this book is, now that I know what kind of mistakes to avoid in CS writing, I see them everywhere. Clearly, more people need to read this book....more

Essentials of Theoretical Computer Science isn't your standard cs theory book. Almost every other theory book I've ever read, including the classic SiEssentials of Theoretical Computer Science isn't your standard cs theory book. Almost every other theory book I've ever read, including the classic Sipser book, starts off with finite state machines, then builds up to pushdown automata, then covers turing machines, in a sort of "lets increase the power" manner. Once Turing Machines are covered, the books cover decidability and reducibility, and complexity.

Lewis's book almost completely flips this around, immediately jumping into Turing Machines, decidability, reducibility, and the difference between recursive and recursively enumerable sets. Afterwards, a more standard approach is taken, covering finite state automata, pushdown automata, and then linear-bounded automata. THEN complexity. Finally, the concept of a grammar is introduced, in the very last chapter.

At first, I was really skeptical of this ordering. It seemed completely backwards to me, but after reading through the book, I've completely changed my mind. This is the ideal order to present this material, and I now consider almost every other theory book to be fundamentally flawed.

Covering TMs first and discussing decidability in the first chapter provides an anchor point for every other discussion about other kinds of sets and automata. And saving grammars to the very end lets the reader focus us reducibility and closure properties of sets without muddying the waters with parsing or the Chomsky hierarchy.

In addition to the completely unorthodox and excellent ordering of the material, the book is extremely readable, written in a conversational, occasionally humorous tone. Proofs are simple and straightforward (as well as ample) and usually followed by a practical example as well to help solidify concepts. Despite the strangeness of the book, I highly recommend it for undergraduates and graduates studying CS Theory.

To make things even better, the entire book is completely free as an eBook from the author on his web site. If you have an interest in CS Theory, you owe it to yousrelf to read this book, which you simply can't beat for the price.