5 comments about Writing Compilers and Interpreters: An Applied Approach (Wiley professional computing).

1. I bought and examined this book thoroughly. There are so many old concepts I wonder whether the author has ever re-read its current second edition. It is supposed to have been written for C++ programmers but of what generation? I understand that the current 2nd edition was written after the release of MS Visual C++ 4. So, the source code still assumes that C++ doesn't have the true and false Boolean constants since the author #defines them, which causes an error in both Visual C++ 6 and later. In fact, the use of #include and void main()indicate that the book is not ANSI compliant. The web site that supports the book provides source code, for MSVC 4 (only after I bought the book, which is extremely expensive, did I find out on the 4th page that it was released in 1996; but the current C++ Standard is from 1998). I tried compiling them in MSVC6 and MSVC.NET. None of the programs compiled (none at all). Even after re-creating the programs by adding files manually, I received many many errors. I tried to fix them and also tried compiling from the Command Prompt, to no avail. It is true that we don't have that many books on compiler development but just as these books are rare, this particular one will be to no help. It is (very) old and its programs don't work. The only things you might get are the authors comments that may help you with some suggestions or guidance, which will be little.



2. This is a down'n'dirty book on how to create a complete Pascal compiler. The book is heavily loaded with massive amounts of code, code which is at times very repetitive, since the author keeps improving on his classes time after time, writing the complete class code each time. If you can read C++ code as well as english, this is a great book to learn every detail about creating a compiler.
   
   The book also cover alot of interesting off-topics, such as programming technique and code management. It is quite obvious that Roald Mak is a very gifted programmer.
   
   I would not recommend this book to anyone who hasn't been doing regular C++ programming for at least 2-3 years. But then again, who else would care about creating their own compilers? ;)



3. This was really my 'practical compilerbook' winner (bought in 1999), until I discovered in 2004 "Programming Language Processors in Java: Compilers and Interpreters" by David Watt, which I like more.
   
   If you're looking for a theory book about compiler design I would recommend 'Engineering a compiler' by Cooper et al.
   
   This book offers a nice compiler (including x86 code generator and debugger!!), for a simple language.
   
   The problem is that the compiler is written in C++, and if you are more familiar with Java you could better buy the book I recommened above.
   
   An advantage of this book is that it also covers rare topics, such as debugger implementation.
   
   A disadvantage is that this book show a lot of code. Actually, all code is printed in the book (as far as I know). That's why it's a big bibble.
   
   The greatest disadvantage of this book is that it doesn't introduce new concepts. It offers a recursive descent parser (difficult to maintain), instead of much faster table driven parsers, or recursive descent parsers made by a generator (ANTLR).
   
   However, this is a great starter for C++ people new to compiler design. Java people would I recommend to buy the book of Watt as recommended above.



4. I am amazed at the positive reviews I have read about this book. Unfortunately, I took their advice and bought it.
   
   The book tries to follow the approach of teaching by example by developing compiler/interpreter components and utilities in C++. Unfortunately, the book reads more like a computer program printout, and rapidly becomes too boring to follow.
   
   There is very little theoretical background to the concepts behind creating compilers and interpreters. Attemping to learn from the C++ code will rapidly confirm that the code is of very poor quality, and seems to be a bodged conversion from C rather than a native C++ development.
   
   Avoid this book at all costs. It is especially dangerous for C++ novices as following the code will teach bad practices and lead you to believe that C++ is just C with classes. It is useless for experienced C++ programmers who wish to learn about compiler/interpreter programming techniques.



5. I read this book in my freshman year long back (2001) -- might have been a previous version. Book is awesome if you know *nothing* about compilers, interpreters, languages etc. I did not know Pascal, had just learnt C++ and (was forced to learn) FORTRAN, knew basic concepts of assembly language and how computers work etc. I enjoyed the book. I never wrote a line of code while I was reading it, but for the rest of my life through college, I have never been afraid about writing my own parser/interpreter/compiler. I had borrowed the book from the library, so for those of you who actually pay for this book, YMMV really.

5 comments about .NET Web Services: Architecture and Implementation (Microsoft .NET Development Series).

1. The author jumps around various topics, and constantly refers to SOAP standard section 5 or 7 in his descriptions. It looks as if he expect the readers to be fully conversant with the nuts and bolts of SOAP spec, and we all know this is a tall order.
   
   Worst of all, he failed to put together even a single real world app to illustrate the best way to make use of web services, TODAY.
   
   He talks about Web service technology as if the tech is an end onto itself.
   
   Don't buy it, you know you don't have time to toil thru a dorky tech spec discussion, esp. when the spec itself is getting out-of-date very fast.



2. Hi,
   
   In the first chapters, where the Keith describes the protocols and underlying technologies of the XML WebServices, the reader gets more question marks in his head only. The explanations are very short. Actually there is no explanation, the author recommends to see the specifications foreach topic. For many things even there isn't any information.
   
   As you read the book, you get the feeling that the author knows everything about web services, but he is not willing to show everything. Maybe he didn't have much time for the book, or had other things to do.
   
   Kaan Ozturk



3. This is one of the most disappointing books I have ever read. I have read a few books in the ".NET Development Series" before and have come to expect solid, easy to grasp, and useful information. This books fails on almost every account.
   
   The explanations are inadequate. The author uses a lot of time to explain the obvious, while failing to explain more complex topics.
   
   The language is really, really bad. An example: "Of course, there are many other applications of routing as well. As well, I fully expect that this specification will evolve over time."!!??
   
   Maybe the most annoying thing about the book is all the dreadful typos and inconsistencies. I have never seen anything like it, and I cannot believe that anyone ever did any proofreading of this book. For example on page 35 he describes a very simple example of a Web Service, a class "TestClass" with one method "Add". On the next page is the image from Internet Explorer which shows what you see when you type the URL of the service on the server, the class is suddenly named "POClass". Later when he describes the SOAP Message for the service it is for another class altogether with a method "HelloWorld"???!!! In this example, it is easy to figure out what is wrong, and it is more annoying than anything else, but in other places where the material is not so easy to understand, the errors are harder to ignore.
   
   Finally and maybe most importantly, the author fails to give any motivation for a lot of the things he does. For example, he describes how one in different ways (by using attributes, etc) can change the format of the soap messages for the service. However, he doesn't say a word about why one should prefer one format for the other.



4. Web service architecture is a big topic and it's not easy to explain well. Obviously the author attempted to explain it but may be due to limited amount of time, his explanation is very shallow and sometimes almost useless: on page 49, he briefly touches how to create object reference with ID/HREF combinations and promises to discuss the topic in Chapter 9 in "greater detail". In chapter 9, on page 183, yes, he revisited that topic but only with 3 short lines of "explanation" which is pretty much the same as that on page 49 - where is the "greater detail"?
   
   The language is bad too: on page 72, "There's a convenient Add Web Reference dialog box...exactly for that kind of thing." What do you mean by "that kind of thing"? Are you writing a professional book or just an IM chat message? Besides, the discussion of creating clients with VS .NET is horribly shallow.
   
   Avoid this book.



5. I'm a Java architect/developer with quite a bit of web service experience. I purchased this book to help me write MS-based web service clients to test interoperability. I found the presentation to be logically structured and very clear. The writing is some of the best technical writing I've seen. It quickly helped me figure out the basics of how MS's web service framework works.
   
   Note this is an older book, so I imagine quite a few things have changed since it was published - although the code generated by the toolkit I just downloaded is compatable with what I see in the book so far. Also, as others have mentioned, this book does not contain complex, real-world examples.
   
   If you are looking for an intro/overview of MS WS technologies, and are willing to hit the web for updates, this book is a good choice.

5 comments about Modal Logic.

1. This book outstands for how the authors present the wide field of modal logics. In a unified framework where classic unimodal logic, dynamic logic and arrow logic are treated as case studies, the authors put forth their view on modal logics as instruments to speak about local properties of relation algebras. This view mandates a novel way to present the subject (this is one of the few books of my knowledge on modal logic which introduces bisimulation from the first chapter), a task that the authors perform wonderfully with a deep and rigorous yet truly understandable presentation of the main issues in modal logics. This is a book whose importance cannot be underestimated. Note however that the book does not treat topics as model checking, mu calculus or properties of a specific logic, be it a K-anything, C/LTL(*), a dynamic logic or whatever. Citing: "The reader looking for a catalogue of facts about his or her favorite modal system probably won't find it here. But such a reader may well find the technique needed to algebraize it, to analyze its expressive power, to prove a completeness result, or to establish its decidability or undecidability - and may even discover that the relevant results are a special case of something known".



2. *The* definitive treatment of propositional modal logic; the vastly more expensive Oxford Logic Guide adds nothing essential to what is also a *thoroughly* up-to-date introduction to the methods of formal logic, concerned less with stylistic beauty than the nitty-gritty of fine structures. How long will it take you to read this? Don't worry about it, because the pedagogical approach of the book makes transitions to more specialized texts on particular topics easy. What's missing? A wide-scope view of computation such as functional programming languages employ, and an adequate explanation for why the practically limited and theoretically thorny modal predicate calculi are excluded (such as one imagines could be whipped up rather quickly using correspondence-theoretic techniques). But for a very reasonable price, you need not feel obligated to join the ranks of contemporary computer scientists.



3. This book is excellent in content. It is definitely not a book that one should expect to read in one sitting, nor two or three. This is a book one needs to grow into. There is a basic track and an advanced track and these are clearly marked throughout the book. It is presumed that the reader should have at least some familiarity with both basic set theory and first order logic. The first four chapters would be the best introduction as a first read. If you are interested in modern algebra, chapter 5 will present interesting connections between Modal Logic and Algebra. The book has several Appendixes: A Logical Toolkit, An Algebraic Toolkit and A Computational Toolkit. These can be very handy if you can't remember what an ultrafilter is or what the difference is between NP and PSPACE. Another very nice feature of this book is that every chapter ends with a historical overview of the people and concepts involved in the material just covered. This really makes the subject more "alive" and makes the study of Modal Logic more purposeful and motivated.

   At the time of writing this, I do not know how this book compares to other introductions to the field of Modal Logic. Moreover, as a student of Yde Venema and of Maarten de Rijke (two of the authors), I am perhaps slightly biased. Nevertheless, I would recommend this book to anyone who wants to seriously delve into the world of Modal Logic.




4. If you're wondering why modal language is so useful but are dismayed about possible worlds, then this is your book. (Side note: when does Blackburn sleep? how can you be at the forefront of modal logic and natural language processing at the same time?)



5. This book focuses on the semantics or model theory of propositional modal languages, introducing a number of model and frame construction and manipulation techniques (e.g. generated submodels, disjoint unions, unravellings, bulldozing); invariance or preservation results (e.g. bisimulations, p-morphism, ultraproducts, ultrafilter extensions); frame definability and correspondence results (e.g. guarded and packed fragments of FOL, Sahlqvist formulas, standard translations); completeness proofs via canonical models; modal algebras; computability and complexity; extended modal languages (e.g. those with nominals (a hybrid language), a global operator, a window operator, a difference operator).
   
   The coverage is very good. In each chapter there is a basic track and then an advanced track. There are also four appendices on first-order model theory, computational complexity theory, universal algebra, and a guide to the literature. Each chapter also has at the end some notes, which include historical remarks and current research and trends in the area. There is an extensive bibliography and index as well.
   
   This is probably the best affordable reference text on modal logic with a heavy model theory slant (which is certainly the current trend). There are more comprehensive texts (e.g. Handbook of Modal Logic by Blackburn et al) but they cost too much for the average consumer or pathetically poor student. Highly recommended.

5 comments about Data Structures and Problem Solving Using Java (2nd Edition).

1. I absolutely love this book. Some of the best code examples I have seen in a Computer Science book. It flows very nicely and has very good explanations of why one way is bettter than another.



2. I bought this book with great expectations after reading the positive reviews. But the book only provides the interfaces for most of the collections (Data Structures?) and provides very similar implementations to that of the SUN's source with some of implementations left to the reader to complete. Instead of buying this book, you are better off downloading the Source from the SUN JDK 1.5 (JAVA 5) and reading the javadocs.



3. book is not so good. explanations are overcomplicated, even for simple issues. If you are beginner get "Teach yourself Java in 21 days" instead.



4. This book is a college textbook for my data structures java class. I was not new to programing at the start of my course, however I was new to OOP. This book does a horrible job of explaining the concept of OOP which, in my opinion, is difficult to grasp at first. The information in this book is very dense. Complex concepts are only given an explanation that is a page or two long (ex: Binary search trees). The examples aren't horrible, but they lack ample documentation. Now that I fully understand the concepts (thanks to the internet) this book makes an alright reference. Overall, if you already know Java or C++ or a similar OO language, this book is probably exactly what you need to learn how to store your data in Java, but if you don't know what OOP is, look elsewhere.



5. I was required to purchase this text for my course. Having never programmed in java before and not having a strong programming background, I found this book almost impossible to follow. This book is definitely not for beginners and assumes previous knowledge of java. I did not find the explanations or examples in the book clearly written. After continued complaints from the class, the professor abandoned the book altogether after just 3 weeks. If your a beginner, stay away from this book.

No comments about The Game Localization Handbook (Game Development Series).

5 comments about Gaming Hacks: 100 Industrial-Strength Tips & Tools.

1. This book covers everything. You can go old school and get information on Mame games and building your own arcade machine. It covers portable with information on PDA games, hacking your Gameboy, and installing a PS2 in your car. It talks about the online world with combat strategies, how to game the systems to make money, and how to find and avoid cheaters. It's got great advice on how to build high end gaming PCs. Consoles are covered as well. He talks about overclocking them and chipping them to play import games. And that's just a sample.
   
   Were this any other type of book I would say that the coverage is unfocused because it's too broad. But it's a Hacks book and these are intended for people with a clue to give them material on a wider range of topics. It starts you off and expects that you will run with it. For example, you get a lot of information about how to create a home arcade machine with Mame, but you won't get the detailed construction plans.
   
   The text is well written, though he does tend to use the gamer lingo, so you may need a translator if you aren't up to the minute. Certainly the best book I have seen for people who want to push their gaming experience beyond what you can get out of the box from Electronics Boutique.



2. If you're a gamer who is always looking for new information to improve your gaming experience, check out Gaming Hacks by Simon Carless (O'Reilly).
   
   Chapter list: Playing Classic Games; Playing Portably; Playing Well With Others; Playing With Hardware; Playing with Console and Arcade Hardware; Playing Around the Game Engine; Playing Your Own Games; Playing Everything Else; Index
   
   Like all Hacks titles, there are 100 hints, tips, and hacks that cover the spectrum of gaming, from hardware to software, from consoles to online gaming. If you're old like me, you might enjoy Play Commodore 64 Games Without the C-64 (#2) and Play Atari ROMs Without the Atari (#3). Those will take you back to your early days of computing. If you're into first player shooting games, Tweak Your Tactics for FPS Glory (#94) will help boost your scoring. Carless will even help you play Japanese video games without knowing the language in #97 - Play Japanese Games Without Speaking Japanese. He shows you some basic hiragana and katakana that you'll encounter frequently in those games, and that might allow you to bridge the language gap.
   
   The only trouble I see with the book is that it's covering such a wide area of subject matter. Unless you're a full-time gamer, you'll probably find a number of areas in this book that don't pertain to your interests. In some ways, that's OK for a Hacks title, as not everything is meant to apply to every single reader. But this particular title seems to be a bit more scattered than usual. The material is good, to be sure, but each reader may have a different opinion of the book based on what their gaming interests are.



3. If you want to go far beyond the obvious, whether you want to modify your console controller to work on other consoles, create your own text adventure, or modify your Game Boy, there is an awful lot of fun you can have for cheap or free, using the creative exploits of the gaming gurus. Gaming Hacks is the indispensable guide to cool things gamers can do to create, modify, and hack videogame hardware and software.
   
   Everything from social exploits and tips to be used in MMORPGs (Massive Multiplayer Online Role Playing Games) to soldering-iron heavy hardware hacks is covered in this extreme-cool hack guide written by gamers for gamers. Gaming Hacks offers a stunning variety of hacks, exploits, and other creative acts on both modern and archaic console hardware and today's PC hardware. One hundred detailed, ingenious hacks are included.
   
   Gaming Hacks also includes detailed software-based looks at MMO (massively multiplayer) titles, FPS (first-person shooter) games, machinima (real-time movies created using game engines), emulation, save-game hacking, and many other miscellaneous subgenres and topics.
   
   Gaming Hacks shows hardcore gamers how to configure the best FPS peripherals, hack the Nuon DVD Player/Gaming System, modify their Game Boy, watch movies and listen to music and their Sega Dreamcast, and much, much more.
   
   Gaming Hacks shows you how to do things you didn't know could be done. If you want more than your average gamer, if you want to explore and experiment, unearth shortcuts, or make your games do what you want them to do Gaming Hacks will show you how. You don't need to be gaming guru to pick up Gaming Hacks, but you will be one when you put it down.



4. This book was a lot of fun to read and provides a lot of great tips for not only getting the most out of your current gaming system, but also for enjoying those games you played 20 years ago. The book starts out with an introduction to emulation and MAME, which allows you to play old console games (like the Atari 2600) or arcade games on a PC. The author even provides directions to illustrate how you can take an old Atari 2600 paddle controller and hook it into your PC (with a soddering iron and a little work). Any gamer who ever played on the Atari would love something like this.
   
   In my favorite chapter, the author shows how to maximize portable devices for gaming fun. In one hack, the author shows how to play games on your iPod. In another hack, the author shows how to produce color pictures from the Game Boy's black and white camera attachment. There are even instructions for turning your PocketPC or PalmPilot into a Game Boy or even a Commordore 64.
   
   The author has a section dedicated to creating the best game machine, where he discusses video cards, mice, and other peripherals. In other sections, the author discusses how to modify your gaming console, including Xbox mods, tunneling (e.g. making games play online that weren't designed to be played online), and other game hacks. Finally, the author rounds out the discussion by demonstrating how to create and add a vehicle to Unreal Tournament 2004. While it does require a bit of time and some work, I was surprised at how relatively easy the whole process was.
   
   This is a great book to read if you enjoy gaming-regardless of whether they're games from 20 years ago or brand new. This book will help you to get the most out of your gaming experience and have a lot of fun doing it.



5. This book covers a lot of ground -- check out the table of contents and you'll see something for every flavor of computer or video game, from the Atari VCS to PC-based first-person-shooters and massively multiplayer online role-playing games, to handhelds like Palm and Pocket PC devices, to all of the major console machines you attach to your television.
   
   Like any computer book, this is full of ephemeral information that may not age well. In a few years, many of the links given here will cease to exist, and much of the hardware referenced could be difficult to find. Some of the tools which seem cool today will be commonplace, having been built into new revisions of hardware. The author does a good job of anticipating where this might happen, and sticks to generalities while providing specific examples wherever possible. As I write this review, the book has been in print for almost a year, and in my opinion, it remains fresh, relevant, and worthy of purchase.
   
   Some of the activity described in this book is in the grey area between legal and illegal activity, and Carless takes care to warn the reader when he/she might be stepping on dangerous ground. Such caveats make this book even more interesting to this reviewer and probably others as well.
   
   If you've ever done any of these things, enjoyed it, and wanted to do more, then this book is for you!
   - played a Japanese game on a USA or UK territory console;
   - played a "hacked" ROM of an old game in emulation;
   - wanted to get more out of old games which are boring now;
   - wondered about nonstandard import adapters and accessories;
   - wanted to interface your console with your PC
   
   In other words, if you're creative enough to want to think outside the narrow box that some manufacturers have put us in, and want more, you want this book, even if you've already done a lot of this stuff on your own. The weblinks alone will provide hours of entertainment, but the book draws everything together into a coherent whole. Cheers to Carless for writing this and to O'Reilly for having the courage to publish this in the age of the Digital Millenium Copyright Act!

3 comments about Compiling for the .NET Common Language Runtime (CLR) (.Net Series).

1. The following review from a CodeGuru member was posted to CodeGuru.com for this book:

   Finally a book written by an author who knows his material and is able to express himself clearly in written form. I have reviewed many books and most of them leave me unsatisfied with the depth of information or the breadth of coverage. This book did not disappoint in either of these areas. It is excellent for those wishing to learn precisely how a language is mapped onto the CLR. Granted not everyone will have a need for such information but if you do then I would not hesitate to recommend it.

   That's the good news, the bad is that this book is not really needed to be a proficient C# programmer. I believe the audience for this book will be very specialized. People interested in squeezing the very last bit of performance out of C# will undoubtedly compare the IL code generated by the compiler and then modify their C# practices accordingly. Others faced with debugging in the absence of a symbolic debugger, embedded environments???, will need to code in C# and then debug in IL. For these types of situations this book will prove to be invaluable.

   The book does an excellent job of taking sample C# code and showing the resulting generated IL code. I can't realistically think of an example of typical code or a typical code sequence that is not covered by one of the many examples. It digs into assemblies, unmanaged code, and interaction with COM. It even goes so far as to describe how name mangling can be accomplished in languages that traditionally do not support such a feature.

   The assumed knowledge section indicates that the reader should be familiar with the basic concepts of programming languages, customary data structures and algorithm theory. I would also recommend that the reader have some knowledge of grammars, lexical analysis and parsing to the level of a first college course.




2. Compiling for the .NET Common Language Runtime is a very complete book and an excellent reference. It provides a solid introduction to the CLR, type system and instruction set (IL). The discussion of code generation for the CLR is thorough.

   An excellent aspect of the book is that it goes beyond the more mundane aspects to discuss broader issues (for example, in mapping language semantics to the CLR). It also manages to include very practical tips such as using the visitor pattern. The book has amazing breadth and depth, yet it is marvelously concise! The writing is clear and easy to understand.

   Every compiler phase (from scanning to code generation) is covered, so the book is very accessible for programmers new to compilation (as I was). However I doubt that more experienced programmers will find it tedious as the chapters on scanning, parsing and semantic analysis could probably be skipped. The emphasis is obviously on code generation, and the usual language constructs (such as loops, etc.) are covered with some interesting discussion. The book also discusses other issues with compiling for the CLR-- using custom attributes, mangling names for languages that don't support method overloading, even dealing with languages with multiple inheritance (the CLR only supports single inheritance).

   The book generates textual IL that is compiled with ilasm, but there is a chapter on using System.Reflection.Emit. This is the only real coverage of an API, so the book avoids any tiresome material that is better left to the MSDN.




3. The book does NOT cover all phases of a compiler as a previous reviewer indicated, such as parsing or designing and constructing abstract syntax trees. It only covers the last phase of generating IL for equivalent Pascal code. In that sense, it duplicates what you can learn from the ildasm and reflector tools, as well as the more recent book Inside Microsoft .NET IL Assembler by Lidin. The book is well written, however I would have liked to have seen more coverage of emitting IL to handle non-Pascal or non-C# features. The book mentions a corresponding website with more code, but I couldn't find much there at all. Also the book suggests looking at "Project 7" by Microsoft which apparently years ago implemented many languages for .NET including Python, but there is nothing about that project available anywhere.
   
   I would recommend the Lidin book instead, plus the use of ildasm and Reflector.

5 comments about Pro Perl.

1. Why? Why do we need another book on Perl that walks through the syntax basics. In it's 1,000 pages this book finishes with Object Oriented Perl. And it spends at least four hundred on the language basics.
   
   Why? Why couldn't this be the 'Pro' book the title describes. This is hardly pro at all. CPAN is given very short shrift. And in general, it's just a rehash of the topics covered in Programming Perl. And Programming Perl is the definitive source.
   
   I'm really not sure why this book was necessary. It does have a different style than Programming Perl. It's a little less jocular and a little more mechanical. Reminiscent of books on Java, C# and Python. It is well written and illustrated.
   
   I'm giving this four stars because I think it will work better for some folks than Programming Perl. Though I think everyone should start with Programming Perl.



2. Remember when Perl was a nice little scripting language? One that you could master in a few days. The success of it led to the incorporation of many new features. Most important of these being perhaps the ability to write object oriented code. The sum total of these features causes a blurring of a difference from "full" languages like C++ or Java.
   
   While it is still possible to program using much of early Perl, this book's aim is to educate you as to the new material. Yes, Perl's scope is now impressive. What with a comprehensive regexp, bidirectional pipes, Unicode and more. How much of this to take in from the book is up to you. Thankfully, the chapters seem mostly independent of each other. So at this level, you have random access, which means you don't have to read all of the book. Each chapter, however, has a strong narrative sense of progress. You should read a desired chapter end to end.
   
   A little irony here. Remember claims by some early proponents of Perl that you could skip the complexity of C++'s STL, for example? Or, more recently, to avoid the bulking up of the class packages in standard Java. Perl now has the same symptoms of success.



3. This is a very comprehensive book for those who want to learn the Perl language from the ground up. The author does an excellent job of being detailed without being repetitive or writing at too basic a level. Intermediate users of Perl can find a lot here but even a novice will find sufficient explanation to allow them to learn the language from scratch. The book is well organized and starts with an introduction to Perl followed by how to acquire and install Perl. From there it goes right into the meat of the language with variables, operators, data types, interpolation, substitution, subroutines, regular expressions, working with files and directories, etc. Besides the language itself the author deals with some of the common administrative tasks like adding new modules and packages. The book ends with some advanced topics like embedding Perl and dealing with processes, signals and threads, and networking.
   
   At 990 pages this is a massive book that is easy to follow and full of examples to show exactly how each concept should work. Pro Perl is highly recommended to everyone from the complete novice to advanced level Perl programmer and includes a lot of detail that I have spent hours on the Internet looking for before.



4. One of my arguments with Perl, which ironically is one of its strengths, is that it is such a powerful language there are perhaps thousands of things that you will never use, or not even know about that the language can do. Once a language relegated to scripting-use only, it has developed over the years into a full-featured language around which applications are being developed from. For example, there are numerous front-end web applications that are built around Perl not to mention in my own line of work we use a number of Perl applications to process and manipulate incoming data. The little kid has finally grown up and matured!
   
   In Pro Perl, the author takes you through an in-depth analysis of the Perl language from the beginning topics up to advanced topics (including a relatively new one for Perl, Object Oriented programming). Many Perl books have a habit of either showing you the basics, and leaving you yearning for more; or showing you advanced topics that you are left scratching your head wondering "How did they jump from A to Z with no in-between"? In Pro Perl the author has taken an approach of explaining the concepts and walking you through the introduction and leading you to the more advanced topics without breaking it into distinct pieces of beginning, novice, etc. The book can be considered more of a instructional reference manual more than a code-snippet type book, which many programming books are nowadays.
   
   One of the benefits this book offers is that throughout the book there are multiple reference charts and tip sidebars that either give you information on a syntax or available options, or lead you on to find more information elsewhere. Personally, I find the reference charts valuable as the author does not leave you guessing what all the available options or for a particular command or syntax -- in essence, he is opening the door for you to explore further on your own by showing you other possible roads.
   
   This is a great book for those comfortable with programming and new to Perl, or those who have used Perl in the past but perhaps wanted to see what else it could do for them. The only thing lacking from the book is an indexing system on the side. It would have been great if you could have just flipped the book open to the appropriate section when you are on those fast-fact-finding missions.



5. I'm only up to page 140 and there are numerous code errors. Some examples:
   
   1) There is a reference to "Appendix A" but there are no appendices in my copy.
   
   2) p 139: he suggests that the expression "\[1, 2, 3]" will return an array reference, but this is actually returning a reference to a reference to an array, using 2 levels rather than 1 level of indirection. This wouldn't be crucial except that this is the section of the chapter/book in which he is specifically explaining references.
   
   Further, while there is a link to submit errata, there is no link for a place to view/download them. Other reviewers have mentioned the frequency of this kind of error.
   
   This book would be a very bad source for someone truly new to perl.

5 comments about Logic and Computer Design Fundamentals, Third Edition.

1. This book is the most comprehensive book ever written on digital logic and computer fundamentals. There is no other way to put it.
   
   I graduated with a CS degree five years ago, and we used "Structured Computer Organization" by Andrew Tanenbaum for class. I feel that the negative reviews written on this book should instead apply to Tanenbaum's.
   
   This is the book we should have used for class in the first place. Here I am five years after graduating, and, only now, after reading this book, I am beginning to fully understand how all the internals of a digital computer work and fit together.
   
   I have no affiliation with the authors nor am I in academia to have any reason defend it. But rather, I am defending it for the wealth of information that was put in it. This is information that is paramount to every CS and EE student/professional.
   
   I bought this book on my own, for self development, and have read most chapters. I had no trouble following the explanations. The authors give the motivation for the study right at the beginning of each chapter, so that readers/students would look ahead and anticipate where and how the concepts and techniques will be used (and where does it apply/fit within the general purpose computer). They first give an overview and then delve into it deeper. I believe that everything should be taught that way, so that people can actually learn what was taught, especially when learning how computers tick.
   
   I have to admit, however, that some of the concepts might be a little advanced if you are just starting to learn about computers. That's why I think that if this book is used in class at some university, it should be taught in two semesters - in order to cover everything thoroughly. There is much and too good-of-information to pass up, to cover the book only partially.
   
   Don't get discouraged when reading this book and find that you don't understand some concepts. Find another lower level explanation to it from a different source, understand it, and then return to the book again and continue. You will find out that by doing that, going through it and learning concept by concept, you will gain an enormous amount of knowledge.



2. 
   Although I'm very sympathetic to the bad reviews of this text, having just used it in an undergrad course I recently completed, I think they unfairly target the book when the courses themselves are probably partly to blame.
   
   Not to say that the 5-star review is perfectly accurate either. You'll probably find that the reason that review was so good was that since the author was 5-years lately graudated from his degree, he was reviewing material rather than learning it for the first time. Even a poor book would be useful for this.
   
   But to my own opinions; I found the book fairly comprehensive, with detailed and complete explanations that could be followed with a little effort. Although it had a lot of diagrams, it was still fairly wordy, which is unfortunate in a technical text. It also didn't have any worked answers to the questions, except some online, which is difficult for a student to get to on a spur of the moment when they need them.
   
   The other reviews are also correct when they say that many of the exercise questions didn't directly relate to any of the explanations in their chapters, but seemed to require knowledge of completely new material.
   
   All in all, this could be a great text if it was twice the size, contained a lot more diagrams, contained at least some worked answers, and made sure that every exercise question was based on theory explanation that was actually present in the book. As it is, it is next to useless as a self-study guide.
   
   What it remains extremely good for is a companion text to a course which includes contact with lecturers and tutors. If the head lecturer makes sure that any theory not covered in the book is covered in class, and chooses exercise questions that they know the students should be able to complete, and if the tutors are accessible for advice, then the text is extraordinarly good.
   
   No offence to the other reviewers, but I suspect that if they hated the book that much, they were either students who preferred self-study to attending class, or their courses were badly structured.



3. This book is Superbly well written and comprehensible. Its is my favourite book in my Library and it has made Digital Systems (A Subject in my Course) my favourite. The book is Good... no kidding. At first when I started reading the book, I thought it was going to be like one of those books that just kept the reader on a Rocking Chair. Fortunately, I kept on reading because I had nothing better to do; as a result by the time I read two 10 pages... I got hooked.
   The book is intuitive and explains lots of Techniques about Implementing Circuits.



4. If you can possibly avoid it, don't buy this book. If you can't possibly avoid it, remember to use the internet. The internet is 3000 times better at things than this book is.
   
   Also, realize that even the problems in this book have continuous typos so if your TA grades you as wrong, check to make sure you are doing the same problem their solution book solved. I wish we could rate this book without a star.



5. The book really lacks clear and concise examples and explanations.
   
   Since the purpose of a textbook is to convey knowledge, if it cannot meet the above goals, the textbook is next to useless.

5 comments about Learning Perl/Tk.

1. This book is little more than a reference guide. It contains virtually no examples and often doesn't even explain how to implement some of the methods it teaches you.

   Exactly how do you pack widgets into a frame? Chapter 12 is devoted to frames and yet it never once tells you how to pack items into one. I eventually had to look this up in a friend's copy of "Advanced Perl Programming" (Chapter 14)!

   What's more amazing is that the book, somewhat perversely, goes into a verbose description of the options for each widget you can create. Why not put this at the end of the book in a table? That's what appendices are for!

   By far the best way to learn is by example and on this front, the book fails miserably. What a complete waste of money.




2. This book would be more aptly titled "Perl/Tk: Lengthy Appendices, with Introduction". As some other reviewers have noted, the book presents the Perl/Tk interface in repetitive and extrodinary detail. Unfortunately, no concise summary of all this information exists on 1 or 2 pages, so the book fails to hold a niche as a desk reference.

   If you're looking for raw and useful code, you'll be disappointed for sure--the book consists of almost none. The in-text examples are short and trivial, rarely serving a useful or real world application. This would not be so bad, had the author included some complete (or perhaps even partial) solutions to the suggested exercises, found at the end of nearly every chapter. Unfortunately, such code is nowhere to be found.

   So what redeeming qualities does it have? I approached this book without experience with GUIs or Tk, and while learning Perl. Through the help of this book I've picked up the basics I need to create programs which allow for simple GUIs to make my programs accessible to those scared of the command line.




3. I used this book to learn the basics of Tk with Perl under Windows, and found it a fine, concise and clear reference. It got me quickly to the point of being able to develop useful graphical applications and gave what I felt to be a good grounding in important concepts and points. It does not address absolutely everything you will eventually need to know, but at least you will have a good grounding and probably find the subsequent learning curve a lot shallower as a result. Important coverage of the geometry managers (pack, place and grid) is well presented and good examples are given. Numerous other possibly trivial but extremely helpful things are here too: how to set the size and initial screen location of Tk-generated window (use the 'geometry' method), a good discussion of the colour-management issues of the various widgets - including how to find the file of colour definitions under various operating systems, and a clear explanation of the various ways to call subroutines (and pass parameters to them) using '-command'.

   Ms. Walsh's style is light and conversational, not at all 'difficult' and without the usual 'clever geek' frills (for example, I personally hate the use of 'foo' and 'bar' as variable and function names everywhere in computing books - it smacks of self-congratulatory cleverness, and more than a tad 'Oh, don't you get it?'). Fortunately that is absent here.

   Highly recommended if you are new to Tk under Perl, as it contains essential information and is well written and presented. Definitely worth the money.




4. This is a solid tutorial that goes through the most important components in Tk and contains good illustrations. You won't become an expert (see that word "Learning" in the title?), and the writing is clear but not spectacular. Before getting this book I tried to read up on Tk on the web and spent many hours trying to get a simple text component to do my bidding. After having read this book, it took me an hour to get the entire app done. Don't repeat my mistake; get this book if you do Perl/Tk!



5. Although I don't program in Perl, I bought this book because it was recommended as a reference for using TK with the Ruby language, since there is no good documentation for Ruby/TK. I found the book very easy to use, and was able to make some fairly complex GUI's pretty quickly. I use the book a lot, and highly recommend it.