5 comments about SolidWorks For Dummies (For Dummies (Computer/Tech)).

1. I love the dummies series, so I was greatly dissapointed by this book. I needed a solidworks tutorial because I found the help files and "basic" tutorials that come with solidworks to be too advanced. When this book is not tooting its own horn on how great solidworks is, then it is way too technical for the beginner. I am a designer, not an engineer. I am hired for the look of a product, not for how it is molded. This book assumes too much. I had to look up chamfer and fillet on Wikipedia, as this books skips the basics and launches into a thou-shalt-sketch-like-this. (again, I am NOT AN ENGINEER) I understand that engineers out there would find this book too basic because it takes half the book outlining anal-retentive ways of structuring workload before launching into actually making anything. [...].



2. This book is written by the Solidworks Customer Satisfaction Manager.
   
   He rehashes the same stuff as in the Solidworks Essentials manual that comes with the software.
   
   I found it virtually useless.
   I was seeking a different viewpoint in the hopes of gaining a better grasp of the many vague issues in the manual.



3. I am still busy with the book but have already started enjoying it. As for Amazone the book arrived one day after their estemated day of delivery Very good



4. This is a good task-based, issues-based overview of SolidWorks. Suitable for today's attention-deficit, info-overloaded, multi-tasked-maxed-out student or working stooge who wants to get a solid beginner's feel for this complex, cool 3D engineering tool--jus' the facts and not a heck of a lot of incomprehensible theorizing. (Of course a committed engineer will need to go somewhere else for the math & other CAD ideas). I'd venture a bold statement and say that this is THE starting point for people considering a career change to this field, and what I liked especially is that the book is pretty clear about being a starting point only. Near the end are the "Ten Tips" for new SW engineers; they make a lot of practical sense. I recommmend pairing this with another task-based product, a video tutorial by VTN, which is also good for the busy beginner who just needs to figure out how to become quickly productive with this tool. Learn SolidWorks by Video - Volume 1 and Learn SolidWorks by Video - Volume 2.



5. I bought this book hoping to learn some little known shortcuts, secrets, etc., but all I got from the book was a different writing of the help file.
   This might be a great book for someone just starting out.

5 comments about Microsoft XNA Unleashed: Graphics and Game Programming for Xbox 360 and Windows (Unleashed).

1. well this isnt realy the publishers \ writer fault but this book is written for XNA 1.0, and once 2.0 had been released some of the code in the book needs a bit of tweaking,
   
   i think that if you have some background knowledge about C# and programming, then this is the perfect book to take you into XNA.
   it has a much better approach then most, "teach yourself" books,
   and i recommand getting it,
   
   it only got a 4 out a 5, but if a new edition with XNA 2.0 will be release i would have givven it a 5.
   :)



2. At first I was hesitant to get this book since it based on the 1.0 refresh. However, I wanted to get started right away and seeing how this technology will simply continue to grow, there is no better time than the present to start learning.
   
   I have all of the current XNA Books available and this one is by far the best. I love this guy's coding style ... it is nice when an author using .NET is actually using .NET styled code. If there is only one XNA book you can buy -- get this one.
   
   I really enjoyed his perspective on performance. It helped me in my day job as well ... can you say Garbage Collector? I bought this book to do 3D and I have been happy with my results. I am using 2D to supplement my 3D game, but it seems the community is obsessed with 2D games at this point. The physics chapter is great. I also enjoyed the chapter on Artificial Intelligence. Both are short, but to the point and helped me know where I need to look for more information. The particle system is excellent. I liked the force field created by particles ... cool.
   
   I am a programmer by trade and have dabbled in computer graphics in the past, but it was just too much work to get anything valuable. With XNA and this book as a guide, I was able to go so much farther than I ever did with DirectX and the books I bought on that subject. I have created a full 3D game that I plan to put out on Xbox LIVE Community Games when it is available. There is no way I would have a completed game without this book -- sound, game states, input, polish -- it is all in here!
   
   I liked how the author didn't waste time on rendering a single triangle ... he did a rectangle (two triangles) ... and then later used that code to create a skybox. The chapter on the content pipeline was excellent. I enjoyed the advanced topics he has as well like Render Targets, Parallax and Relief Mapping.
   
   In regards to changes with 2.0, he has updated the code on his site and it runs with no issues at all! Fortunately, the code is about identical to what it is in the book even with new code. I guess it just proves that not too much had to change between 1.0 refresh and 2.0.
   I would buy this book again. In fact, I will when the author comes out with the 3.0 book.
   
   Get this book ... and don't waste any more time ... make a great game -- it really is within grasp!



3. This is a very well planned book with game development students in mind. Readers who complain that the writer takes off too quickly should keep in mind that the book is categorized as "Intermediate-Advanced" and quite accurately so.
   
   I'm using this as a recommended text for a module I am teaching to diploma students and it brings them up to speed on programming with XNA.
   
   You should get this if you have programmed in DirectX and/or C++; you'll find it a breeze and be amazed by how many things have been taken care / made much easier by the XNA framework and using a managed language such as C#.
   
   The author, Chad Carter, also actively responds to the questions in the book's discussion forums. This is especially important for a technical book such as this as technology is constantly evolving (we're at XNA 2.0 currently), and it helps to know which parts of the book need to be updated (or not).
   
   The only improvements I can recommend for the next edition (XNA 3.0) are:
   1. Consolidated list of errata on the author's website (xnaessentials.com) to make it easier to find and update my own copy / students' copies of the book.
   2. Teaching / supporting materials. However, I must admit that going through the exercises in the book will give you a good deal of ideas and inspirations already.
   
   In short, thanks Chad, please keep up the excellent work.



4. The book assumes you know C#, and basically takes you through the development of a 2D game and a basic 3D FPS style game. As new functionality is added, the book explains the code pretty much line by line. It therefore shows you two sets of simple game design patterns in some detail.
   
   It also makes the book very linear - as new functions are shown in the context of what has been built already, you can't easily just experiment with the different classes on their own. You really have to follow it through as a sequential tutorial.
   
   What I was more hoping for was a more systematic treatment of the various XNA classes, and more of the underlying theory particularly with respect to using transformations. Matrix and vector maths is barely discussed directly at all.
   
   The linear structure and practical focus also means that I didn't find myself able to "dip into" the book and learn more about XNA whilst watching TV for example.
   
   So if you want an extended tutorial on XNA game programming its fine. If you want to really "get inside" XNA and graphics programming, then its not the right book for you.



5. When i started to get serious about XNA i started looking for a good book to begin learning. Like most people (IMHO) i learn better through books and then self training than reading everything online.
   
   The Microsoft XNA Unleashed by Chad Carter is a great book as it is not merely a skim through from the top for XNA but is very detailed. I have just started and i dont think i will be done with the book very soon.
   
   I like his presentation style as well as the detail. I read all the reviews and sure some folks think it is a good book whereas some folks think otherwise. For me when i started reading through it i immediately liked the presentation style. I think (IMHO) that a good presentation style with good material leads to better learning.
   
   I will post an update to my blog as and when i complete this book. Based on my initial 80 or so pages, i like it a lot.
   
   See my blog http://ilovethexbox.blogspot.com/2008/06/microsoft-xna-unleashed.html for updates to the review.

1 comments about Building Flash Web Sites For Dummies (For Dummies (Computer/Tech)).

1. This is the book I reach for when I'm looking for quick concise descriptions. I almost use it as an extended glossary. The index is great. There are subjects I find in the index that I cannot find in the indexes of more comprehensive instructional books, nor the online Flash help. I can almost always find what I'm looking for. I thought I would outgrow this book as my skills increased but I find I still use it all the time.

5 comments about Computer Graphics: Principles and Practice in C (2nd Edition) (Systems Programming Series).

1. It's an all-time classic in computer graphics world. I bought this in 1997 and i could learn a lot from it. Though it hasn't been updated, one can gain all the fundamentals about CG.



2. This book is a great book for general knowledge but all of the chapters that deal with talking about hardware is badly outdated. I got this book mostly for algorithms. I got much more then what I expected but most of everything I needed was there. Its a very good book for learning about line drawing, and polygon rasteration algorithms. Don't expect anything up to date like shaders though.



3. Except for the chapters on raster algorithms, this book is just an extended bibliography. It has no material on texturing, for example, just a reference to the original paper on it. The math isn't that mature either, and the chapter on Perspective Projections is a pedagogical atrocity. Instead of buying this book, just go to your local univ. library and xerox the bibliography; then, lookup the articles on topics you're interested in.



4. If you're a beginner looking for a book which has example code you can test out and try, either forget it or be prepared for some headache.
   
   I can speak on my experience, I have a GNU/Linux system, the SRGP library which is used by this book only supports a display depth of 8bpp, which means you'll most likely need to reconfigure your X server to some extent - the examples/library will crash at higher display depths.
   
   But there is no doubt that the techniques and principles explained throughout can be applied using other toolkits, as the book explicitly says that the facilities contained in the example libraries are common to many other graphics libraries.
   
   A quick note on the quality of the library code, it appears to be pre-ANSI C and contains a few modern no-nos, which can lead to crashes.
   
   If you're looking for a book to merely use as a reference or for theory then this is what this book is, and as one other reviewer said, you could probably just borrow a copy of the book and xerox the bibliography to refer to the papers it sources information from.



5. This is a bible for computer graphics. I recommend this book to anyone who wants to learn computer graphics knowledge base.

5 comments about Modern Applied Statistics with S.

1. This is a great programming reference book for S-plus or R. I would imagine any serious programmer in S-plus already has this on his/her desk.
   
   Nice feature about this book:
   where S and R differs in grammar, they are labeled very clearly.



2. I started using R to do linear modeling and found that I was using 'library(MASS)' much of the time. MASS, it turns out, stands for Modern Applied Statistics with S. R is a free ware version of S-Plus. I assumed that R is simply S-Plus without the GUI. I was close, but not right. There are some minor differences. This book, written for S also addresses the use of R in the applications presented, and also notes differences between the two, when they exist. I am quite pleased with Venerables and Ripley's book; it presents much of the theoretical background as well as 'command line' code for doing the analyses presented in each chapter. The book assumes the reader has some background in statistics.
   
   The first five chapters are a brief overview of /introduction to S-Plus (or R). These chapters present enough information and examples to make the rest of the book fairly easy to work through.
   
   I got the book primarily to work design of experiments. The chapters on linear statistical models and general linear models were perfectly suited to my needs. Topics like factorial experiments, random and mixed effects, nested designs, partially balanced designs are covered. In addition, techniques of robust analysis and bootstrap methods are presented.
   
   The book covers many other areas - non-linear models, classification, time series, optimization.. I have not worked through any of these topics in the book.
   
   Overall I find Modern Applied Statistics with S to be an excellent book, invaluable if one is using R (I don't have S-Plus) as the vehicle for analyses.



3. This is *the* book to have on S+/R. It provides excellent value for its price (indeed, any price): it is concise, broad, informative. All the same, I think it would be useful to identify intended audience for this book (in my view). First, the book is not for novices in Statistics. You'll learn how to fit generalized linear models in the language, not how and why to apply such models properly. To this end, there are plenty of specific monographies, and the majority of them use R for examples. Just to name a few, Friedman, Hastie, Tibshirani, Harrell, Faraway employ R. Also, this book assume some basic knowledge of programming. R is a more elegant language than Matlab and Thinking in R becomes very natural after some practice. But I have not seen so far a tutorial on "R as a first language". Summing up, this is a great book for undergraduates in Statistics/Engineering and up, who want a comprehensive, usable reference. My only criticism is that since 2002 there have been giant changes in the language. First, R is now the main implementation of the language, with S+ being an industry-supported variant. Second, the S4 object model is here to stay and grow, and is crying for a user-friendly introduction. Lastly, the number of packages is probably twenty times what it was in 2002. SVMs, ensemble methods, shrinkage, sparse representations *are* modern applied statistics, and are underrepresented in the book.
   
   Still, this is a must have for any applied statistician.



4. This text is very popular and frequently cited in the statistics literature. The authors do an outstanding job of displaying modern statistical methods through the S programming language. It is an intermediate level book and certainly worthy of 5 stars.



5. Who is the books audience? Its a second book. A second book to a theory book. A second book to a textbook. A second book to a your lecture notes. It will never be ~the~ book for a topic by itself, but it just a brilliant job of filling gaps.
   
   I picture it like this: if your going into a graduate program that uses R buy this book and you will use it. 2 out of 3 courses I took in spring semester used R heavily. I am surprised none of the instructors had the line "Recommended for students continuing in R is MASS..." in their syllabus. Because that is exactly what I would say. This is one of those books you want to get early, and keep it around.
   
   It never explains enough of the statistics to stand on its own; however, its coverage of R and R packages is more complete than anything I have found elsewhere. And having got it a year after I first started using R, I am sad I didn't get it sooner =)~
   
   If you're changing topics alot like a student does is it ~the~ desk reference for R? Probably. Maybe I will run into a better one in a few months though? I dunno.. you get it and tell me.

1 comments about Painting the Web.

1. In spite of the huge number of graphics on the Web, the practice is surprisingly underserved in terms of the literature. Of course, there are design books, books on software, but these focus on best use of a product. The nuances and requirements for the Web are harder to find.
   
   This book is a practitioner's book. And, it's a quite personal work. Written in a conversational style, it's easy to read. The author covers a wide range of tools which she uses on a regular basis. That includes a variety of less-familiar open source tools.
   
   There is a great deal of HTML, CSS and JS code related specifically to graphic representation. It's really convenient to have this foundation in one place.
   
   At first glance, one might be surprised at the detail given to techniques of Photoshop and other tools. But again, as a practitioner's book, it reflects the techniques useful for specifically Web design. It's handy to have these in one place for reference.
   
   Because it is a rather personal work, there will be emphases that one might change. There is a significant amount of space spent on SVG -- which, although a standard, I think is problematic because of the lack of inherent support in IE and Adobe's discontinuation of the plug-in. In any case, weighing in at 638 pages, there's a lot of good information, regardless of one's personal opinion.
   
   The focus is on traditional and standards-based HTML programming. The author does broach the canvas object -- a part of the HTML 5 standard which provides another route to animation on the desktop. However, IE8, at the time of the book's writing, didn't support this object. There is no coverage of Flash, and Silverlight is mentioned simply to identify another non-standard MS approach. Indeed, both Adobe and MS focus their energies on Flex/Flash/AIR and Silverlight technologies respectively to provide a richer Internet experience.
   
   As fits a book on graphics, illustrations are in color. This adds a lot to the vitality of the read, and helps portray information in a useful way.
   
   As the author notes, no one book can address the many issues related to web graphics. This book is of a different character than Weinman's Designing Web Graphics.4. Though in need of an update, that volume presents a more structured and a complementary perspective to the present.
   
   In any case, it's a good addition to the Web designer's bookshelf.

5 comments about XML Pocket Reference.

1. The majority of the new material in this book is on different schema specifications. Schema, Relax NG and Schematron are covered. A handy book to have around when you are hacking XML. The online free documentation is not as handy as the content as it's organized in this book.



2. The other review book I received yesterday was XML Pocket Reference (3rd Edition) by Simon St. Laurent and Michael Fitzgerald. Depending on what you're looking for, this may or may not the book for you...
   
   Contents: Introduction; XML Structures; Document Type Definitions; W3C XML Schema; RELAX NG; Schematron; XML Specifications; Index
   
   Admittedly, trying to cover "XML" in a single book is a daunting task. XML is made up of so many standards and technologies (XPath, XForms, XML Schema, etc.) that you either have to specialize your coverage area or be ready to publish a *really* heavy book. To their credit, the authors stripped out XSLT into it's own pocket guide. That act keeps this particular book small enough to fit in your pocket and that's good. But if you're wanting information on XSLT and think this might be your book, forget it.
   
   Next, the XML Structures and Document Type Definition chapters seemed to be a little confusing. There was something introduced that I had never heard of before... something called "Productions" followed by syntax that looked like regular expression language. Never having seen that term before in my XML reading, I went back to the introduction to see what the authors wanted to convey there. The only explanation was "As each structure is discussed, applicable productions from the XML 1.0 and 1.1 specs will be listed in the order in which they appear in the specs." So, I still really don't know what productions are, and I probably have to go to the specs to find that out. The description of each section in an XML document, like CDATA or declarations, was nice though.
   
   The book starts to become really useful when you get into the XML Schema section. There they go into each of the elements along with each attribute that can be used with the element. This is the type of reference information I'd expect to see in a pocket guide. Something I can turn to quickly as a refresher for what parameters or attributes I can use with an element, or to gain a quick understanding of an element I haven't seen before. This same structure is followed for the RELAX NG and Schematron schema languages, so the book will be helpful if you live in those worlds also.
   
   Basically, I found the XML Pocket Guide to be a little "hit and miss". If the title had been "XML Schema Pocket Guide", I'd have felt like the book was pretty on target. Trying to call it the XML Pocket Guide seems to infer there's a lot more in here than there actually is, and a buyer might get a copy and be highly disappointed in what it doesn't cover. If you're looking for schema info, you'll love the book. If that's a secondary reason for you to get the book, you might be disappointed.



3. My problem with this book is that I was hoping it would concentrate more on just XML Schema, something I think most people would prefer. Of course, how I am qualified to make that kind of statement is beyond me ;-) But here is my reasoning: A fairly large portion of the book covers DTDs, RELAX NG, and Schematron. DTDs, while ubiquitous, are being supplanted by XML Schema. Usage of RELAX NG and Schematron are, by the book's own admission, not widespread. So it seems that all three of these technologies could have been admitted, as were many other XML-related technologies (XSLT, XPath, etc.)
   In addition, I feel the regular-expression-like inclusions should have been omitted. These include something referred to as Productions in one part of the book and Contents in another. Maybe good for hard-core CS people, but pretty much useless for those of us who just want to work with XML Schema. An ideal replacement would have been some examples illustrating sample usage of various elements and attributes.
   All in all, the descriptions accompanying the elements and attributes are pretty good. Unfortunately, that accounts for only about one-third of the book. But it only costs $10 and it is small, so maybe it's worth it.



4. I am one of the coauthors of this book. I feel compelled to write a review in support of my friend and coauthor, Simon St. Laurent, who wrote the section on XML Schema. Of the 160 pages of text in XML Pocket Reference, Third Edition, 71 pages are dedicated to XML Schema. That's 44 percent of the book. Of the 71 pages, 16 pages cover examples of XML Schema.
   
   DTDs are covered in 15 pages, RELAX NG in 32, and Schematron in 10 (57 pages total). XML Schema receives the most extensive treatment of any of the topics covered, and within the limitations of the size of the book, Simon did an excellent job.
   
   XSLT and XPath were not included in this book because a new, separate volume has been dedicated to those topics-XSLT 1.0 Pocket Reference, by Evan Lenz, which also appeared in August 2005.
   
   As for the production rules, they were included for programmers and others who need grammars. The productions, which come from the XML spec, are a means for understanding XML syntax precisely, and it would have been unwise, in my view, to omit them.



5. I bought this guide because I needed a quick lookup for XML schema elements (something you'd think would be readily available online, but isn't - at least not in a usable form). The bulk of the book (70 of its 162 pages - about half) is dedicated to XSD, so I was very happy with what I got. The first 30 pages cover XML itself (all the nitpicking details like predefined entities, what characters are allowed in attribute names, etc). The next 17 pages cover DTD (which you may occasionally still need to know, even these days). The next 70 cover XML Schema, and the book finishes up with an additional 43 pages on Relax-NG and Schematron (two competing, and not very common, schema definition formats).
   
   I agree with other reviewers that the book would have been complete without the Relax-NG and Schematron coverage, but it would have just been 43 pages shorter if that was the case - there's really not much else they could have said about XML, DTD and XSD and still have been a concise "pocket reference". This book is actually pretty thick for an O'Reilly pocket reference - I have four other pocket guides on my bookshelf right now, and the other three have 120, 124 and 66 pages each. By that standard, I figure the coverage of Relax-NG and Schematron were just a "buy one get one free" type of add-on, especially since this book costs the same as all the other pocket reference books.
   
   This book is a perfect reference for somebody who needs a quick, handy reference to XML schema and the occasional XML rule.

2 comments about Advanced 3D Game Programming with DirectX 10.0 (Wordware Game and Graphics Library).

1. So, the title of this book is "Advanced 3D Game Programming With DirectX 10.0", which seems to imply that the text is designed for intermediate/experienced programmers who want to up their skills to the next level. This book isn't really "advanced" at all -- it's an introductory DirectX/game programming book. So, keep that in mind if you're looking to buy this.
   
   However, if you're an experienced C++ programmer, but you're a newbie to DirectX game programming, then this book is absolutely perfect. It covers DirectInput -- teaching you the fundamentals for programming input in your game in a very straightforward non-pretentious manner. Direct3D, typically daunting to newbies, is given a very lucid, clear, and succinct treatment. Walsh also covers more advanced topics like scene management (in truth, he glosses over it, so you'll need to do additional reading elsewhere, but it's a good start...), pixel/vertex shaders, and several cool graphics techniques (pre-computed radiosity was especially cool).
   Walsh also covers the rudiments of network and sound programming, so your game will be "complete".
   
   I guess what I like most about this book is that while it's not too in-depth with regard to any topic, it goes over the basics of all necessary game programming topics, so that you can start writing basic games immediately (full games, mind you...not just a flyby through a room of cubes). It's a great fundamentals book that, if you read and understand fully, will allow you to transition relatively painlessly to more advanced books/techniques.
   
   While I was tempted to give this book 4 stars for the misleading title, I simply cannot find it within myself to give a book that is so good at what it does lesser than a 5.
   
   Oh, and for those of you wondering, "where do I go next after this book?", here's a list of what I'm using as a hobbyist graphics/game programmer...I hope it helps:
   
   - The ShaderX series (advanced real-time graphics topics)
   - GPU Gems series (more advanced, scientific real-time graphics topics)
   - "3D Game Engine Design" by David Eberly (great book that teaches you how to design a professional quality game engine)
   - Real-Time Rendering, 2nd edition (all the real-time graphics considerations and algorithmic fundamentals are here)
   - Game Programming Gems (these are like the ShaderX/GPU Gems, only for general game programming, including math, sound, input, graphics, scene management, etc.)
   
   I hope this review helps anybody interested in becoming a game programmer!



2. I have read Peter Walsh's other book about Direct X 9.0 called "The Zen of Direct X Programming" (or something like that) Anyway, that was way better. Actually the previous book mentioned was awesome, that is why I bought the "Advanced version" except the "Advanced version" is by a different publisher who probably said to Peter... "Don't be funny in your book, be boring, don't explain things, anything you do explain, explain it poorly and don't give any good examples." And that is the book for you.

5 comments about MySQL Administrator's Guide and Language Reference (2nd Edition).

1. The MySQL Administrator's Guide by MySQL Press is the ultimate reference for anyone installing, upgrading or maintaining the MySQL database server. I found this guide to be completely invaluable when using MySQL, even before I had downloaded the software. The Guide uses clear, easy to read, formatting which makes shell instructions stand out from MySQL statements. A detailed index takes no time to show you where in 600 pages your answer lies. And you can bet you'll find the answer in this Guide. Beginners beware, however, this is no introduction to MySQL. Readers should have a clear understanding of their system, along with experience of MySQL, although an insight into MySQL AB and MySQL's history is included in Chapter 1.

   As I began reading through this Guide, I couldn't help notice immediately how it sets itself apart from similar books. The MySQL Admin Guide has a detail which you will not find anywhere else. Such is to be expected from the company who make the software, and this book certainly shows the high quality of MySQL. After reading through this book, I can't help but agree with Kaj Arno (Vice President Software Engineering, MySQL AB) who is quoted on the back page; "'It is not possible to find a more thorough and more current reference in print, anywhere'". One of the best example I can make of this fact is in Chapter 2 which focuses on Installing MySQL. Not only does this Guide list all the option of a source distribution, all the ins and outs of installing MySQL on all likely platforms - Windows, Mac OS X, NetWare, Linux and other general Unix systems - this guide also deals with Upgrading and Downgrading the most recent version of the MySQL database server. And of course, to ensure that the entire knowledge is in print, Perl installation notes are included too. What other book covers the often troublesome installation process in almost 150 pages of detail?

   And that's only the second chapter. Throughout the book you're assured to find comprehensive information straight from the people who know it best. You may think that this book simply offers too much information, and for most people I would have to agree. It is unlikely to bother a system administrator how MySQL server optimizes the WHERE clause, or how to avoid table scans. Even if someone was interested in understanding something like this, they'd have the opportunity of looking at the MySQL Reference Manual online. So why buy the print version? The printed Guide not only allows for offline viewing, it also includes information which has not been included in the Reference Manual, such as how details are stored and the many feature of MySQL's MaxDB. If your not content with only having part of the story, you'll want to get this Guide.

   The MySQL Administrator's Guide is the ideal book for system administrators who want to get the most out of their MySQL server. With all the advice on installing, maintaining and administering that you'll ever need to know, this Guide by MySQL AB is ideal for those who long for a comprehensive printed reference.




2. This is a good book gives out the details in an easy to understand format.



3. Good stuff. But the MySQL Administrator's guide (2nd edition) and Language reference is out and on Amazon. That contains the same book in a later edition with the language reference on CD on top of it. Buy that instead.



4. This is an excellent book, but it is written for MySql 5. Check your version before buying.



5. Excellent delivery service and the condition of the book was new. The price was also excellent.

5 comments about Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level.

1. I earned my Computer Science degree several years ago. During my studies I learned languages like Assembly, Modula-2, C and C++ and even a little VB in a computer graphics class. I learned quite a bit about how computers work at the binary level and even got into some Electrical Engineering topics.
   
   As you might expect, I don't use any of those languages in my career today. It's all Java, LotusScript, and other high-level languages for me these days. I rarely find myself shifting bits or thinking about logic gates. Does this mean my CS degree was a waste of time? Absolutely not. Although it would have been nicer if I had been learning Java... :-)
   
   It's not the languages I learned that gave the education its value. It's the algorithms, patterns and logic that have come to my aid again and again. An understanding of what's going on inside the computer can be very helpful at times. That's why I was so interested in reading Randall Hyde's book: Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level.
   
   This book teaches the following concepts (Chapter 1 excerpt):
   - Why it's important to consider the low-level execution of your high-level programs
   - How compilers generate machine code from high-level language (HLL) statements
   - How compilers represent various data types using low-level, primitive, data types
   - How to write your HLL code to help the compiler produce better machine code
   - How to take advantage of a compiler's optimization facilities
   - How to "think" in assembly language (low-level terms) while writing HLL code
   
   The general goal of this book is to teach you how to think like a compiler so you can anticipate what the compiler will do with your code. Randall Hyde is also the author of The Art of Assembly Language. It would be an understatement to say he has a good handle on this subject. Chapter 3 goes into detail on 80x86 assembly for the HLL programmer while chapter 4 looks at the Power PC. Chapter 5 looks at compiler operation and code generation. This chapter gave me major flashbacks to compiler class.
   
   In chapter 9, the author includes a great discussion of arrays and how they are handled by various languages. Another topic, in chapter 12, that I found very interesting was the discussion of variant data types. (Us LotusScript developers mustn't forget to use 'Option Declare.') Chapter 15 includes a description of various types of loops and hammers home the importance of coding efficient loops.
   
   We spend so much time these days trying to abstract everything and think at a high-level. That's all fine and good but we can make better high-level decisions by understanding the low-level workings of compilers. Readers who are experienced developers with a genuine interest in writing quality code will get a lot out of this book. I especially recommend it for career developers who didn't have the benefit of formal Computer Science training.
   
   At the end of the book is a teaser for the next book in the series: Write Great Code, Volume 3: Engineering Software. In this book, Hyde will discuss "personal software engineering" and will focus on craftsmanship, art, and pride in workmanship. I'm looking forward to that one too.



2. Back in "the day", you really couldn't write high-level code without at least some exposure at some point to lower-level code, like Assembler. Now, you can pretty much be completely ignorant of what happens in your Java or VB code "under the covers". But that doesn't mean you can't benefit from understanding how your compiler turns your readable code into machine-readable operations. Randall Hyde does an excellent job in explaining all this in his book Write Great Code Volume 2: Thinking Low-Level, Writing High-Level.
   
   Contents: Thinking Low-Level, Writing High-Level; Shouldn't You Learn Assembly Language?; 80x86 Assembly for the HLL Programmer; PowerPC Assembly for the HLL Programmer; Compiler Operations and Code Generation; Tools for Analyzing Compiler Output; Constants and High-Level Languages; Variables in a High-Level Language; Array Data Types; String Data Types; Pointer Data Types; Record, Union, and Class Data Types; Arithmetic and Logical Expressions; Control Structures and Programmatic Decisions; Iterative Control Structures; Functions and Procedures; Engineering Software; A Brief Comparison of the 80x86 and PowerPC CPU Families; Online Appendices; Index
   
   This is the type of book that will really excite you if you're wondering why a nested if statement performs differently than a case statement. Hyde explains basic compiler theory, and applies that to how your compiler of choice decides on optimization strategies. It's impractical to get a program optimized for all factors, like code size and speed, but there are reasonable trade-offs as well as compiler options you can use to prioritize one factor over another. You also don't have to be completely conversant with Assembler in order to work through this book. He uses a number of high-level coding examples from various languages (like C, C++, and Pascal) that should be understandable to most any IT developer. He then shows the translated code at the assembler level and explains why a particular compilation might be good or bad (depending on your requirements). Once you start to understand how (and why) your compiler "optimizes" your code, you can make more intelligent choices as far as programming constructs. There is often a dozen ways to do something, but a few of those ways will be far more efficient at the machine level than the others.
   
   If you're writing a program that runs in a second or two, these techniques may not necessarily have an immediate practical application for you. But that hour-long program may have the same underlying problem as your first program, and it could be that a slight change in program structure at your end could dramatically reduce the run time. This is one of those books that most serious software developers should have sitting on their shelves...



3. The first 100 pages of this book were fantastic for concepts. After that, there were numerous code listings of various dialects of assembler that were each several pages in length. The premise is that you should learn to read assembler so that you can write better high level code. However, there is no tutorial on what the various assembler keyword instructions mean. This book feels like it was slapped together because it was the long overdue volume two in the series, and has so many references to the first volume that you practically need to own both. There is not enough on Java (or OO in general) as the reader's high level langauge of choice, and far too much on Pascal.



4. In this RAD time when anybody who knows drag-and-drop can proudly claim himself software developer, this is the unique book for true, serious, and hardcore programmer that writes native codes. I completely agree that, in order to write efficient and optimized code, you not only need to understand what your compiler can do for you,but also you should know, at least for a minimum level, what you can do for you compiler. In this regard, this book does an excellent job explaining the magic your compiler does for you and what you can do to become part of the magic. As such, I highly recommend this book to any serious programmers.
   
   The only thing I don't like about this book is that it appears to be giving too much space to HLA, which I suspect is a widely accepted assembly dialect that was actually used in any real-life project. And I just feel it is a waste of my time trying to understand and catch up with this HLA language. This results in my taking one star off with the final rate of 4 stars.
   
   Other than that, this is indeed a very good book.
   
   In a previous reivew, it is complained that Java is not touched. This is understandable while it really doesn't seem to be a problem to me. Java after compiling is translated into bytecode that has to be executed on the virtual machine. I guess that is really beyond the intended scope of this book, which is related to the world of native codes that after compiling can be directly executed by the machine.



5. How Software Works would also be a great title for this volume. Any high level construct you can think of is analyzed in-depth at a low level. This is great for those interested in reverse engineering or writing cleaner code.
   
   This book is language and hardware neutral. Languages from Pascal to C++ to Visual Basic are covered on hardware from x86 to RISC to embedded systems. No matter what language you code in the innards are laid out for you. The author does a masterful job of the idiosyncrasies of different languages seamlessly without dwelling on the trivial. This book is heavy on assembled code, compilers, and interpreters. It's an absolutely great collection of everything you wanted to know about how software works that you really can't find elsewhere in a single volume.
   
   Although the subject matter is probably dry for some, I found this book surprisingly easy to read due to the clarity of the writing. This is at least as good, or better than volume one. With that said, there are a number of references to volume one, and I do recommend reading volume one first unless you have a solid background in computer architecture.