Reviews (30)

Great start for Java programmers
I bought this book a couple of months ago and was on and off studying Java on my own, but I must say, overall its an excellent book if you are a novice to object oriented progamming. Just pratice making some of the programs that the book offers as problems and you should be fine. Like anything, if you don't make an effort to understand whats in the book and pratice the problems given, its useless.

A Good introduction to programming & Java
I found this book pretty neat if one wants to develop an object oriented approach to programming .Though java is not covered exhaustively, but it does give the beginner a feel of how java works.I had a teacher to go along with this book & that too helped to get the maximum from the book

Editorial Review

With Teach Yourself C++ in 21 Days, author Jesse Liberty presents a rapid and well-organized program for getting up to speed in C++ programming. By making the seemingly complex world of C++ digestible in daily doses, Liberty delivers a tutorial that keeps you motivated and yields serious results.

This book uses a chapter-a-day approach, with the course outline clearly presented inside the front cover so you'll know exactly where you're headed. Unlike many C++ tutorials, this book doesn't put you to sleep early on with object-oriented programming (OOP) theory. Instead, it quickly makes you productive with the basics of the C++ language and then reinforces your new knowledge with OOP as you move through the teaching program.

The first week introduces you to the fundamentals: the anatomy of a C++ program, variables, expressions, functions, program flow, and the basics of classes. Week two introduces some of the more sophisticated elements of the language such as pointers, arrays, and function overloading in a clear and effective manner. The final week concludes your crash course with advanced topics: streams, advanced inheritance, the C++ pre-processor, templates, and error handling. One day is also devoted strictly to object-oriented analysis and design. Each chapter finishes with a daily summary, a Q&A section, a quiz, and a series of excellent coding exercises.

Reviews (10)

Informative & well-written, but needs more solutions
This book is a well-written and concise treatment of abstract data structures.I used it to prepare for graduate level study that requires prior knowledge of abstract data structures, algorithms, and Java.Thechapters are very well laid-out, the explanations are clear, and the codesnippets are serviceable.

I had two main problems with the book.First,the chapter on graphs and trees was far too advanced for a CS2 student. Second, the author left key programming concepts as problems forassignments, rather than introducing the material in the body of the book. An example is rotating a binary tree in order to balance it: the generalidea is introduced, but techniques were left to the student to devise; OK,I figured out at least one way, but it would be nice to know about otherswithout chasing down another textbook.

A final positive note: theappendix introducing the Java language is complete enough that I used it asmy primary reference in learning the syntax of the language.

This book is thorough and clear, but it needs more material
As a student who completed a data structures course using this book, I believe that I can offer a review that has special insight that might be lacking in a typical review.

Overall, the book is very solid, and itaccomplishes its purpose. Standish takes a naturally abstract topic andprovides numerous visuals and models to help the student visualize ADT's.Without these models, a data structures book would not only be extremelydry, but also difficult to follow. This is certainly the book's strongpoint. There is no doubt in my mind that Standish is a great teacher ofdata structures because of this. Also noteworthy is the setup of the book.Recursion, a difficult but essential topic in computer science, is coveredearly on. For the CS2 programmer, recursion can be very difficult at times,and it is critical that the reader understands the value of incorporatingthis technique into ADT programs. In addition, chapter 5 covers modularityand information hiding, which partially introduces the essence behindADT's. I think this is a great placement of this chapter, because when weget into real ADT's, like Stacks and Queues, we understand the purpose ofADT's: all we need to know now is the operations that Stacks and Queueshave to offer. In short, this placement of the chapters allows for quickand easy understanding of a subject that is not concrete by definition.Another good point is its sorting chapter, which covers almost any sortingand searching algorithm you could think of, including Radix Sort andProxMap sort, which are difficult, if not impossible, to find in other datastructures books.

The only negative point about the book is the price.For its price, the books should be 50-100 pages longer. And by that, Idon't mean extending long appendices, which contribute to the mediocrethickness of the book already. When I finished the book, I thought I gotmost of what data structures in computer science had to offer. But I wasdead wrong. I found another book (I don't recall the author) that coveredtrees which I never heard of, and other advanced ADT's like binomialqueues. Sorry, you won't find anything like this in this book. In addition,there just aren't enough exercises offered in this book that present anyreal challenge. That may be up to the ability level of the programmer, butin most exercises, all that is required to complete them is just a simplemodification of a source code example. That, in my judgment, is not enoughif one wants to build up any skills in programming.

In conclusion, thebook may have its shortcomings, particularly in its length, but overall,its fabulous explanations of an obscure topic more than make up for anyfaults. This book is excellent for an intro to data structures ONLY!

it's decent, but too expensive
The book is not bad, but not that good either and the $56.90 I paid Amazon for it is too a high price.

Good things about the book-
It has a compact size and it has these 2.5 inch margins for people to write stuffin; comments for the code are in a special color; nice pictures; neatinformation - such as a table of frequencies of alphabet letters (thesection about Huffman encryption); also, a nice bibliography at the end ofevery chapter - so we can buy more stuff from this guy...; finally, most ofthe information is quite useful or important - it's not a book with a lotof junk in it.

Now the bad things about the book -
It simplydoesn't cover enough stuff and it should be priced at about $20 rather than$53; Besides 2.5 inch margins, the Appendix stretches from page 423 - 545,so there's not that much material; To make everything worse, I think theauthor talked way too much about Java language specifics - instead of beingthe 100% data structure book with examples in Java code, the book is like a75% data structure book and 25% Java language review session. The reviewsmight be helpful for other people, but I just skipped over 25% of the book.More importantly, the code in the book is way too cryptic cause the guykept using these 1 letter variable names (p for pivot, R for right, L forleft, i, j, k, sometimes do NOT stand for counters in for-loops)

Reviews (27)

Poorly Written, No Answers to Exercises, Avoid purchase.
Another drab computer science book written by someone who likes to complicate the obvious and oversimplify the complicated.
It is obviously geared toward dry mathematical types, and if you're one of those it might possibly be partially stimulating. The mathematical notation is unfortunately quite poor, many letters (which seem to represent constants and sometimes variables?) are ambiguously defined. Not to mention how half assed the "proofs" are.My linear algebra and differential equations teacher would roll over in her proverbial grave.

The code examples are halfway decent, however using one letter variable names is something a beginner quickly learns to stop doing.Why does this guy do it?
The one thing that I like is his use of line up curley braces.
Requiring readers to visit some website to obtain portions of missing code defeats the purpose of writing a book.
Why don't I just read a bunch of webpages instead of buying this flavorless thing.Code "snipits" are another big mistake, they're only understood if their context is explained well, which this shabby author cannot do. He seems to assume we have some clairvoyant abilities.A hint of color might at least keep me awake, but I guess that would have required putting some thought into the book's layout.

The hash table chapter is a wonderful example of how this author is a detached weirdo who can't put himself in the place of his readers. Saying "in the above example" in reference to an example that was FOUR pages ago is thoroughly idiotic and unnecessarily confusing. Several "examples" appeared after the one he referred to. Naming the page number would only take a few more letters i.e. "in the above example(p.54)"
And saying "using the same hash function" after showing us 3 different hash functions has the same perplexing effect.How about "again using h(x) = x%10," it would use less ink and make more sense.

The true reason I hate this book though, is that its exercises have no answers, not even to the odd questions or just some selected questions.Nothing.
Thus, the exercises are completely useless.
In order to prepare for my exam I've had to check out other books because this one doesn't cut it.I even found a much older edition of this book and by its similarity it's clear he's just recycling it for financial gain. Again Exercises and no solutions. How do I know if I'm doing them correctly?! As with physical exercise, exerting yourself the wrong way can be quite detrimental!
This author needs to take a communication 101 class or read some of Deitel & Deitel's books.Avoid purchasing this book unless you have to!

Read description: for ADVANCED data structures course
Many people on here have complained that this book goes way over the head of students not already familiar with some C++ and data structures. To these comments, I refer you to the product description (or editorial review, whichever) that specifically says this is an advanced text. I apologize to those whose professors ordered this book for intro data structures--I can understand why this book would go past the scope of that class. However, if you know any Object Oriented programming (Java or C++ preferably) and know some basic algorithms and structures (matrices, sorts, recursion, trees, queues, etc.) this book will take you far. I don't even mean that you must be proficient in these structures, just have some basic understanding of how they work. For example, you should know what a tree is (root, leaves, implemented with pointers and nodes) and book will tell you how to use trees (B-Trees, Binary trees, etc.). By the point you are using this book, hopefully you'll have taken the math and programming classes needed to comprehend this text. Otherwise, do not blame the text for being targeted to an advanced audience.

Reviews (13)

Better than his other one.
In first year engineering at Simon Fraser University, many of my classmates and I absolutely hated Mano's other text, "Logic and Computer Design Fundamentals (2nd ed. updated)". However since I have picked this text up I have found Mano to be much easier to read, but that could be because I have adjusted to the material and his writing style.

Unfortunately there are no solutions to any of the exercises in this text, only selected answers. His other text has some solutions posted on the companion site (http://www.prenhall.com/mano/), you may be able to use them to learn from with this text as well.

And there are little mistakes in the text that may make things difficult to understand at first, but I did find a decent errata on the web (http://www.ece.uvic.ca/~amirali/courses/CENG290/textmistakes.html).

I don't know how good the text is for self-teaching, but it isn't bad for brushing up on the basics after being away from digital design for a couple years.

Too many errors
This was the text book used in one of my computer science courses.
Trying to learn from this book was very difficult because there are many errors in the diagrams. Considering that diagrams are a vital part of a book on computer circuitry I would have expected the diagrams to be accurate and replete with detailed explanations. This book is in its third edition yet it somehow manages to still have errors, this is inexcusable; were it the first edition I may have been more lenient. If you look closely you will find errors in many of the diagrams, sometimes two or more errors on the same page. Definitely not worth the $100+.

Reviews (15)

Nice and Simpe Introductory Book
I have three of M. Mano's books and this one is the one I've liked the most. I found the author's exposition of the material good on average. I'm using this book for self-study. The book provides a nice overview of computer architecture by focusing on the basic concepts in manner that is not dependent on a particular real-life architecture.

I must say however that I gotten up to chapter 11 and have become totally unmotivated to finish the book (only two chapters left). I've gone through most of the interesting problems of each chapter but have no clue to the 'correctness' of some of them since the book doesn't come with solutions.

One thing that I really dislike about a book is the lack of an errata sheet. All of Mano's books I own lack an errata sheet. I've noticed some errors in the book although nothing major.

Recommendation: As far as I know there are no really good books in the area of computer architecture. If you're looking for a simple introductory book on computer architecture, I would recommend this book. Avoid this book if you're looking for a more technical treatment on the subject.

Great book to learn about the innards of a CPU
It's hard for me to believe this book didn't get good reviews. It's an awesome book that succintly details the design of a CPU. The author uses a hands on approach by showing you how to design a simple CPU from scratch. Even though simple, this CPU has a useable set of instructions (including IO ones), interrupts, and a memory subsytem. RTL is used to convey what is done at each instruction cyle, which is great. For me, this is the first time
I see a practical application of RTL. The book could have been more interestingif it provides an implementation in VHDL, or Verilog, but i guess that's left as an excercise for the reader.

Reviews (8)

Good book for introductory level
This book builds knowledge from ground up so it is a very good book for people who have no background in computer science or computer engineering.Appendices are very neccessary materials if a reader has no background in this area at all so I would recommend to read the appendices first if you have no background.

It's too bad...
I've had Vincent Heuring as a professor.All I can say about the book is that it's a good reference for a professor doesn't cover his own material well.He attempted to explain things in class, but could never quite come through.The books helped greatly in clarifying his lectures.

Reviews (70)

Thorough and Easy to Use
He gives you all of his examples with the CD, and lists everything step by step.If you currently know C and want to learn windows programming, this book is a MUST for you.He teaches you everything that you need to know to program in Windows.Examples were extremely helpful.Warning, if you want a book to just "gloss" over and teach you, then this isn't it, and you probably won't find one for Windows programming.If you want to really learn step by step, then you will love this book.

outdated
This book will be outdated soon, wait for the 6th edition. There are also much more concise books on the market that teach windows programming.

Editorial Review

The second edition of Jeff Prosise's Programming Windows with MFC is a great introduction to the programming language that will help you build client-side applications in MFC. Though it doesn't cover Internet development, this title provides a worthy tutorial on traditional MFC programming.

After some MFC basics, the book looks at Graphical Device Interface (GDI) graphics with a fine discussion of drawing and font handling. Following this, Prosise introduces the use of the MFC collection classes (an alternative to STL) and file I/O, as well as adding serialization support to custom classes.

He also dedicates a fair amount of text to basic Windows controls and dialog boxes. His tour of support for both the Single Document Interface (SDI) and Multiple Document Interface (MDI) application styles is just excellent. The built-in view classes in MFC and how to use them in a Windows Explorer-style sample program are covered. From there, it's on to other common GUI interface models such as toolbars, status bars, and the new Internet Explorer-style rebars. After a useful section on printing (including some valuable real-world tips for this tricky topic), the rich array of Windows common controls is discussed. As in the first edition, Prosise's introduction to MFC multithreading and synchronization objects (like mutexes) is a standout.

The last section of the book provides a comprehensive discussion of COM and ActiveX programming for the MFC developer. Although the Active Template Library (ATL) is omitted here, there are fine examples of building and using ActiveX controls, including the basics of OLE automation.

Reviews (26)

It's a sleeper
I haven't found any reason for someone to buy this book. The writing sytle is dry. The examples are complex and poorly explained. The concepts are covered adequately, but often with a wordiness that leaves the reader bewildered (if still awake). As an "Introduction" manual, this text fails miserably. I'd have given it zero stars, if possible. It just does not do anything well, and does too many things poorly. There's too many well written texts in the world to waste time with this one.

Simply godawful
I had to purchase this for my school's Intro to CS Theory course.

Linz' utter ineptitude towards writing is what gives this book 1 star.Examples throughout chapters are sparse and relatively worthless.Sample problems at the end of the chapter, in contrast, are ridiculously difficult, and the solutions in the back don't offer any explanation whatsoever towards the answers.

This is the only book I have ever read that actually made me feel dumber for reading it.It's simply demeaning.Rather than explaining or justifying his logic, as he should to the target audience of this book, he simply uses "it's obvious that..." repeatedly for sample problems and solutions.A ridiculously complex problem's solution in the back of the book will be whittled down to two lines at best, half of which says something along the line of "It's blatantly obvious that the answer is ___, and you're stupid for not realizing it."

If you're actually assigned graded work from this book, may god have mercy on your soul.

Reviews (15)

Very nice book
I only bought this book because I needed to get an image of how fixed length records are implemented using C++. The book answered my question and provided me with examples. The examples compiled without a problem.

4 stars instead of 5, because I had to write my own Makefile in order to compile. Aparently, presented makefiles were designed to compile all examples at once, and I only needed a little piece of that.

Also, the information is a bit scattered around the book and it is not always easy to find what you need. But it is there, so you just need to work on it. After all, this subject is not covered at all in other books, so I would say it is a must have book for any programmer who works with files.

easy to use
i love this book...used it in my file structures course obviously, and i found it very useful

Plenty of great information, could have been presented bette
This text was used for a junior-level File Manipulation Techniques course.We skipped around quite a bit in this book and did not use any of the C++/Unix material.I think (and I'm sure my professor does) that this book could be stripped down a quite a bit to present more topics when used for the classroom.What is presented is done well.This is a well-rounded text that should appeal to students and professionals alike.However, from the student's perspective, there is a lot of superfluous material.It is still one of the best, if not then it is the best, book on file structures and algorithms.

The programs for class were in Visual Basic .NET .It was not hard to adapt sections from the text when writing programs for a different language.

Our class moved through the book as follows:chapters 1-4 (introduction to external storage, files of records); start of chapter 8 (cosequential processes); chapters 5 and 6 (record access, insertion and deletion); end of chapter 8 (sorting large files); chapter 11 (hashing); chapter 7 and 9 (indexing and B-trees).

Isbn: 0201741539
Sales Rank: 553114
Subjects:  1. Computer Bks - Data Base Management    2. Computer Books And Software    3. Computers    4. Database Management - General   

Editorial Review

Operating systems are large and complex, and yet must functionwith near-absolute reliability--that's why they're a class untothemselves in the field of software development. Since its firstrelease 20 years ago, "the dinosaur book"--Operating SystemConcepts by Abraham Silberschatz, Peter Baer Galvin, and GregGagne--has been a valuable reference for designers and implementers ofoperating systems. The newly released sixth edition of this bookmaintains the volume's authority with new sections on threadmanagement, distributed processes, and the Java Virtual Machine (JVM).There's also information on the workings of the latest crop ofoperating systems, including Microsoft Windows 2000, Linux, FreeBSD,and compact operating systems for handheld devices.

This book isconcerned with the design of operating systems, which is to say itenumerates the problems that pop up in the creation of efficientsystems and explores alternative ways of dealing with them, detailingthe advantages and shortcomings of each. For example, in their chapteron scheduling CPU activity, the authors explain several algorithms(first-come, first-served, and round-robin scheduling, among others)for allocating the capacity of single and multiple processors amongjobs. They highlight the relative advantages of each, and explain howseveral real-life operating systems solve the problem. They thenpresent the reader with exercises (this book is essentially auniversity textbook) that inspire thought and discussion. --DavidWall

Editorial Review

As a textbook suitable for the classroom or self-study, Michael Scott's Programming Language Pragmatics provides a worthy tour of the theory and practice of how programming languages are run on today's computers. Clearly organized and filled with a wide-ranging perspective on over 40 different languages, this book will be appreciated for its depth and breadth of coverage on an essential topic in computer science.

With references to dozens of programming languages, from Ada to Turing and everything in between (including C, C++, Java, and Perl), this book is a truly in-depth guide to how code is compiled (or interpreted) and executed on computer hardware. Early chapters tend to be slightly more theoretical (with coverage of regular expressions and context-free grammars) and will be most valuable to the computer science student, but much of this book is accessible to anyone seeking to widen their knowledge (especially since recent standards surrounding XML make use of some of the same vocabulary presented here).

The book has a comprehensive discussion of compilation and linking, as well as how data types are implemented in memory. Sections on functional and logical programming (illustrated with Scheme and Prolog, which are often used in AI research) can expand your understanding of how programming languages work. Final sections on the advantages--and complexities--of concurrent processing, plus a nice treatment of code optimization techniques, round out the text here. Each chapter provides numerous exercises, so you can try out the ideas on your own.

Students will benefit from the practical examples here, drawn from a wide range of languages. If you are a self-taught developer, the very approachable tutorial can give you perspective on the formal definitions of many computer languages, which can help you master new ones more effectively. --Richard Dragan

Reviews (47)

Still don't have the dragon book?
Compiler design is a huge field. This book is a mirror of this field. The language is clear and the notation used by authors simplify understanding of the material.This book covers the main arguments relevant to compiler design:

1) Introduction to compiling
2) A simple one-pass compiler
3) Lexycal analysis
4) Syntax analysis
5) Syntax-directed translation
6) Type checking
7) Run-time Environments
8) Intermediate code generation
9) Code generation
10) Code optimization

plus other chapters with some hints and a programming project.

Some people said that this book is too "heavy" for an introductory course on compiler design. I think that all people reading a book of this entity should have at least a basic understanding of theoretical computer science, like finite state machines, grammars, and regular expressions. All the material is well organized.
The book starts with an introduction to compiler design, ideas and basic principles. Then it develops concepts in the rest of the book. Of course this is not an easy reading but this is not a problem of the book. Compiler theory is complex and this book try to explain it in the clearest way possible.
I like this book, after reading this you'll have all the skills to read more advanced books about this subject.
This book has always been considered the standard textbook about compiler design and I recommend it to all people interested in this wonderful subject. Highly recommended.

Trivial, non-constructive, hard-to-follow, terrible
The worst textbook I've ever read.
For Many times I've been confused by the author's explanation for some very simple ideas.

Reviews (23)

Maybe it's just me
I find this book lacks explanation at many points, to where I couldn't understand thw way the author presented a problem, a subject, etc... I almost feel like the target audience is to other college professors, and not students of the subject.I also don't like that a lot of the harder problems at the end of the sections are even numbered, so that you don't have a way to see how they are worked.I don't really feel the book warrants just one star, but since most people in my class don't care much for the book, I am confused to all of the great reviews on this web site and felt I needed to show the contrast that my class experienced with it.I think the book requires a good instructor to help you get through it, in contrast to the comments to others who have said it's good for a self learner.I am also enrolled in Calculus 2 and Linear Algebra, and the books I am using for those courses are FAR superior to this one. and I have missed a few class sessions in those two courses and am still running a high B and a mid A in those courses.I wouldn't dream of missing a class in the Discrete Math class because I feel too dependant on the instructor's explanations.

great book on discrete math
This is an excellent book for self study. However, there are parts in this book that must be rearranged or deleted. For example, I think Catalan numbers should be deleted. This might be useful for the matrix chaining problem, but that's in the realms of algorithm design (specifically in dynamic programming). Also, I do not understand why Grimaldi sandwiched in a chapter on Finite State Machines between two chapters on Functions and Relations. Maybe he should make a section on languages for FSMs, but I recommend Sipser's

Reviews (2)

An excellent introduction to higher mathematics
I thoroughly enjoyed my modern algebra class, with an excellent professor and this excellent book. The book is very clearly written, and the concepts of sets, groups, rings, fields, and number systems are explained with detail. This is especially important since my summer research in number theory requires an understanding of these algebraic structures.