5 comments about Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) (Pragmatic Programmers).

1. There are dozens of technical books on my bookshelf, most of them quite good... but none as relevant and valuable an addition as Release It! If you are a professional involved in the development, deployment, and production support of modern information systems it is in your interest to get a copy of this book and (unlike many a technical manual) *actually read it*



2. I just completed reading Release It! by Michael T. Nyggard (Pragmatic Bookshelf 2007). It is part of The Pragmatic Programmers series. I have read the book cover to cover twice. At first, I thought that the book was just another book on how to manage projects. So What! The ideas presented in the book were common sense. I have been doing these same things for many years.
   
   Then one day I was working on a project, and was trying to figure out how to handle a problem. I remembered what I read in Release It! about the topic. I grabbed the book off the bookshelf and looked it up; logging. The ideas presented are common sense, but how often have we missed to boat. The ideas presented in the book I implemented much to my own joy. The result was a customized deployment of the Java Logging system which is simple to maintain and does not require external libraries.
   
   It was at that point I realized the brilliance of the book and the pragmatic side of things. I re-read the book. As an architect, project manager, developer, and maintainer of complex software ecosystems, the ideas in the book provide a "pragmatic" common sense approach to handling situations. The book is a learning tool, one person's personal perspective on software design and deployment, and a reference. It is an all-in-one book.
   
   This book provides a great tutorial on how to manage complex projects for the novice, and a gentle practical reminder to the seasoned architect/project manager.
   
   The book is divided into 4 major sections: Stability, Capacity, General Design Issues, and Operations. The first two sections provide the basis for the remainder of the book. The Stability and Capacity sections have divided the topic into an explanation, followed by general design patterns and anti-patterns. It explains in enough detail how to implement good patterns and recognize bad ones.
   
   The section on General Design covers items like Administration and Security. There is nothing earth shattering in these sections, but they do provide a basis for a "check list" of items to make sure you consider in your designs.
   
   The final section on Operations is the one where you will make friends with your administrators and keep your sanity. The portions on designing for monitoring including logging will be your savior at 2:00 AM in the middle of a blizzard. The discussion on designing for the future does not get enough attention in our modern get it out the door now world. This may be the push you need to think about it.
   
   This is a book to have on your bookshelf. Mine is full of tabs and post-it notes.



3. Unlike many books (such as those with animal kingdom on their cover or photos of several programmers) this book is by/for a real software engineer with real life production ailments and antidotes for them. Even if all the use cases discussed here may not be applicable, if people follow at least 50% of those that apply I think there will less business outages, better user experience and a happier IT department.
   
   On top of all the good technical stuff, this book also happens to be well written - enough to be just enjoyed for the anecdotes and such.
   
   A must read for any software engineer of web applications!



4. Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) (Pragmatic Programmers)
   
   This book offers very sound advice, based upon Author's years of experience. Every serious developer/architect should own it. The only reason why I gave it 4 stars is that the book is devoid of code; it would have been % star plus, book had Author put some code samples there (even pseudo code or more diagrams).



5. This is a book of advices on how to make the system running. Not just to write and release it (no pun intended), but to keep it running after the release.
   
   The book is about prior planning for capacity and stability, designing systems capable of handling the load while being resilient and fault-tolerant, build it in a maintainable and adaptable way, so that it lives through the years. A great deal of information in it too.
   
   Overall, it was a pleasant reading, because in most parts it matches precisely what I'm doing on my job and what I've learned to be the right way of doing through hard experience. As always, such practical convergence with published material is very comforting.
   
   Why did I give it 4 stars then ?
   
   Because the book itself needs more work.
   
   It is poorly structured and is stylistically informal. It doesn't have a plot, but it is also not a collection of independent essays or articles. Near the end it feels like the author just gave up the structure and stuffed the book with random thoughts.
   
   Despite the author's promise for each part of the book to have a case study, only 3 out of the 4 unconnected book parts are opened with one, and the studies are of anecdotal nature. A few pages of horror in everybody's eyes to find out that a janitor had accidentally pulled the plug, something like that.
   
   As the few architectural patterns suggested by the author reside near the middle of the book, the first half is full of forward references, like "but wait till you see the MagicPattern !". The patterns when you encounter them are useful but are explained shortly and in informal manner again.
   
   A lot of assorted hints, ranging from TCP handshaking to stripping whitespace off web pages and wrapping a web service around a database. Interesting, but inconsistent.
   
   It is difficult for me to be unbiased about a book like that, because, like I said, it correctly describes many of the practical considerations that I already knew in the first place.
   
   I'd say it is the kind of book for the architects with development past. It will be useless for you unless you have a lot of practical experience as a developer. On the other hand, if you are a beginning developer, it won't help much either because it doesn't offer any analysis or any kind of formal textbook kind of information.

5 comments about The Ultimate CSS Reference.

1. Every part of CSS is covered. The browser support and compatibility is given for every property. The layout is extremely well thought out and makes finding information incredibly easy. And to top it all off, Sitepoint makes the book available on-line as well, for free. It is fully searchable. This is just a great tool for anyone working on site design.
   
   As others have mentioned, if one is looking for lots of tutorials or help in learning how to do CSS, they may want to supplement this with something else. This is mostly just reference with brief introductory information. But that is what makes it great. A person who already knows what they are doing does not have to wade through a bunch of explanation and teaching. This is just the facts.
   
   I highly recommend this to any serious web developer or designer.



2. §
   
   In the ancient days of early 1999 I had to put together my own CSS reference. I had to figure out by trial and error what parts of CSS were implemented and which were most useful and least buggy. Back then it seemed most Web experts / lecturers were very wary of CSS because the leading browser company, Netscape, did not see the transformative potential of HTML stylesheets.
   
   I uploaded my "Cascading Style Cheatsheet" (http://home.tampabay.rr.com/bmerkey/cheatsheet.htm) and over the years it has become a popular link. We really don't need attempts of that sort anymore when we have books like this one.
   
   Like its companion volume (The Ultimate HTML Reference) this book is simply but elegantly laid out in a way that makes it easy to use. The language is clear and the examples are directed to the most useful aspects of serious Web page and Web application implementations.
   
   Because I make my living designing Web applications based upon the Internet Explorer browser, I was pleased to see excellent coverage of the proprietary (but very useful) CSS properties and values. Many books do not mention these because they are not part of the W3C specification. For good measure, a sprinkling of the -moz extensions of Firefox are also covered.
   
   This book, sitting alongside its HTML companion, should be a solid (hard-backed!) addition to your technical library.
   
   §



3. Any computer collection catering to programmers and covering CSS will find "The Ultimate CSS Refrence" to be the definitive work for mastering CSS, the building block of nearly every web site today. Written by two of the world's most renowned CSS experts, "The Ultimate CSS Reference" features extensive tips, facts, and detail. A perfect for college-level or advanced computer libraries.



4. The ultimate CSS reference by Tommy Olsson and Paul O'Brien is exactly what it says, a reference guide. As with all books however I've read this one cover to cover. The book covers every single CSS keyword, selector, pseudo-class and corresponding attribute known (including some that aren't even in the official ratified W3C standard but are supported by certain browsers and some that are currently in the standard but aren't supported by any of the major browsers) from CSS version 1 right through to the latest CSS 3.
   
   The book is very well laid out and easy to look up as a reference with chapters on layout, list styles, box properties etc. Next to this is a quick reference stating whether or not the attribute is inherited, it's initial value, which version of the official W3C specification it comes from and a quick browser support reference stating whether it's fully supported by the browser, partially supported, not supported at all or whether the implementation is buggy for a particular browser. This is followed by a description of what the attribute does, any values that it takes followed by a more complete browser compatibility list. The list covers the major browsers that are currently out from IE5.5 through IE7, Firefox 1.0 through 2.0, Safari 1.3 through 3.0 and Opera 9.2. Following this is a brief description of any compatibility issues as listed .
   
   As with any book of this nature, basically it is out of date virtually as it's printed. With Firefox 3.0 and Opera 9.5 just being released and Internet Explorer 8.0 just around the corner. However this and it's companion Ultimate HTML reference are definitely two books that I'd love to see updated once the new set of browsers are out.
   
   Scattered throughout the book are numerous references to W3C RFCs, web sites showing compatibility issues and differences between the way various browsers handle the CSS etc. that are very useful.
   
   This book is a must for any web developer no matter which programming language you use to build your web sites. Combine it's sister book with this one and you really do have the ultimate web reference sitting at your fingertips. No more looking through obscure RFC's. When you're designing a web site and come across a quirk in how you thought something should have been laid out, or a CSS selector then simply reach for this book and it will tell you if indeed it is a bug or whether you are just implementing incorrectly.
   Tommy and Paul should be proud of what they have produced and this book should grace every web developers desk and be within fingertip reach.



5. Overall I give this book four stars. This is a REFERENCE book; not really intended for beginners. However, I read about some properties I did not know existed previously, so I learned a lot in addition to having one place to look up everything. I do like that it's hardcover--though I wish one of these days Sitepoint could make books that are able to lay flat!
   
   I also like the fact that after every property, there is a little box that explains which browsers are compatible with it. The book even explains if the property is buggy (looking at you, IE), and then delves into why and if there is a fix. Unfortunately, this list will soon need additions to them, with the coming of IE8, Chrome, etc, etc. Still, very useful.
   
   It doesn't receive a perfect five because I wish more example pictures could be displayed. I don't mean for the very basic things (like the height property). In some of the explanations, I was only 80 to 90% sure of what the paragraph was talking about, and with web I am very visual. I know this would have taken up more space, but I felt it was needed (but only for certain sections). I also didn't like how the "index" is set up. I think there should have been another index (keywords) in addition to the current, property-only one. For instance, div isn't even mentioned there. I know that's an HTML tag but it would have been nice to see all the keywords throughout the book regarding it, considering its interaction with CSS. I guess I'm not used to that sort of index, which is basically the Table of Contents but at the end of the book.
   
   So yes, I would say if you want one book to look up all the different properties of CSS, this is it. Again, this is a reference, not a book with tutorials and explanations on how to create something specific (recommend the anthology book for that).

4 comments about Unleashing Web 2.0: From Concepts to Creativity.

1. This book is an excellent book on Web 2.0 technologies and how they can be used to provide value to users in a Web 2.0 world. The book is a light on technical (programming), but rich on concepts and the business side of Web 2.0. What makes this book useful is the fact that it reintroduces common concepts such as blogs in a way that an executive can understand and take advantage of. The first chapter discusses a brief history of the web. The second chapter goes into explaining what web technologies such as CSS and XML are and what a web service can do for a business. There are a few other very useful chapters in this book, but by no means you should stop your Web 2.0 quest with this book. This book's a great way to start your Web 2.0 journey and it even puts forth the notion of semantic web. But, once you figure out what area you want to concentrate on, I recommend getting a more comprehensive book on that specific topic.



2. I borrowed this book from someone who knows a great deal about web directions, and I found it to be very very good. Although the authors do not reflect the tsunamis being created by Doug Englebart (Open hypertextdocument system or OHS) and Pierre Levy (Information Economy Meta Language or IEML), this is a very elegantly organized and presented book.
   
   It forced me to question my here-to-fore blind expectations with respect to the Semantic Web where in practice the theory of seamless integration has not been realized. I was especially taken with the author's conclusion that we must continue to develop applications for smallish communities of practice where the human brain continues to be the primary searcher, sorter, and valuation or linkage agent.
   
   Jim Bamford's book on the National Security Agency (NSA), Body of Secrets: Anatomy of the Ultra-Secret National Security Agency, concludes that one day NSA may--after spending hundreds of billions more of our hard-earned wages, create the ultimate computer--one weighing very little, running on virtually no energy, and able to do petaflop calculations per second: THE HUMAN BRAIN.
   
   I am among a handful of co-founders of the Earth Intelligence Network, and I will conclude this very favorable review with my opinion: the World Brain is emergent, and it is the end-users, as the co-authorrs of this book conclude, that will continue to be the primary content creators, content sharers, and content valuators.
   
   As soon as China and India figure out they can create infinite wealth by handing out free cells phones and offering their respective 1.5 billion poor free information and education "one cell call at a time," it will be game over for both American and European digital ambitions.
   
   Machine learning has been over-hyped since the 1980's, and while I respect the computational mathematics being pioneered by Google, and various deep web or meta web endeavors, the reality is that search today stinks, yielding less than 2% of relevant information. I don't expect that to be resolved anytime soon. What I *do* expect is for humans empowered by relatively simple tools, to figure out how to do a national referendum from neighbood to nation=state, in 24 hours, and how to mobilize a public cabinet that posts a sensible slate of policies backed up by a balanced budget.
   
   See also:
   Mobilizing Generation 2.0: A Practical Guide to Using Web2.0 Technologies to Recruit, Organize and Engage Youth
   Society's Breakthrough!: Releasing Essential Wisdom and Virtue in All the People
   How to Change the World: Social Entrepreneurs and the Power of New Ideas
   Global Brain: The Evolution of Mass Mind from the Big Bang to the 21st Century
   The Tao of Democracy: Using Co-Intelligence to Create a World That Works for All
   The Wealth of Networks: How Social Production Transforms Markets and Freedom
   Global Assemblages: Technology, Politics, and Ethics as Anthropological Problems
   Collective Intelligence: Mankind's Emerging World in Cyberspace (Helix Books)
   Collective Intelligence: Creating a Prosperous World at Peace



3. When I first heard the term "Web 2.0," I dismissed it as hype left over from the dotcom days. What I've learned since is that Web 2.0 is a phenomenon that has forever changed the way we use the Internet. And while the 'Net is constantly changing, Web 2.0 is definitely NOT hype and it's time we all learn to use Web 2.0 to the best of our abilities. What I like about this book is that the authors describe various Web 2.0 technologies like XML web applications, Rich Internet Applications (like Google online documents), Application Programming Interfaces (API's), Web procedure calls (WPC), Ajax client and server-side applications, metadata and the Semantic web.
   
   There's also items like blogs, wikis, and social networks. These are all explained in great detail in this book. There are also apps called "mash-ups." Before reading this book, I thought "mashups" were combinations of songs created by club DJs. Internet mashups aren't all that different combining different web programs to create something new and useful. RIA's have become quite popular. Think of Google online documents or spreadsheets.
   
   The book starts off with a brief history of the "browser wars" between Netscape and Microsoft, then discusses developments in web technology (HTML, XML, CSS, etc), along with the emergence of client and server side applications enabled by using JavaScript and PHP, and then goes in more detail about RIA's, mashups and the phenomenon called "tagging." Tagging consists of tags that contain information about a site, photo or link that can be used by others for a wide range of uses.
   
   There's also a chapter in the book devoted to the social implications of Web 2.0; items like business models and the social impact of online social networks like MySpace.
   
   The authors did a great job in describing their topic. I appreciated their detailed look at Web 2.0. It makes an excellent "starter" book on the subject.



4. the book mentioned semantic web. And the steps in promoting semantic web. The concept of web 2.0 is clear.

5 comments about J2EE Web Services: XML SOAP WSDL UDDI WS-I JAX-RPC JAXR SAAJ JAXP.

1. just started reading it.easy to read ,has a good flow,clear explanation.i think it will be a good resource for my current web services project and if i take the certification exam too.



2. Perfect book for a beginer. The book starts from basics to leads complex points in a balanced manner.



3. I got everything i need in this book. This is very helpful for the sun exam also....in one word, this is the bible of webservice.



4. This book is not a book teaching you programming WS step by step. It is ideal for Enterprise and Soultion architecs, who need to familiarize with the technology stack under SOA and WS*. It is an encyclopedy, which covers these standards and technologies in a very intelligible way. It covers the concepts and principles, not coding details.



5. This is a useful book. In one project that I worked on I was a consumer of a web service and had to learn very quickly how to process a SOAP message. The chapter dealing with the SAAJ api was quite useful in this respect.
   I've skimmed through other chapters on a 'need to' basis and found them instructive also. If there's one criticism I'd say it's short on solid complete working examples. Other than that, I'd recommend it to anyone trying to understand the Web Service labyrinth.

5 comments about Python Essential Reference (3rd Edition) (Developer's Library).

1. This book is a highly detailed reference to the Python language. The introductory chapters build on one another and give the reader a decent introduction to the language. The later chapters need not be read sequentially as they are a reference on more advanced features.
   
   The book has superb coverage of distutils, C extensions, network I/O, and introspection. The index is well organized so you can find text on obscure, subtle concepts easily. Need to know how to raise an IOError in C? Not a problem, it's in there. Need to know how to quickly generate a tuple from C? Not a problem, it's in there. Need to know how to split apart or join paths and filenames in a platform-independent way? It's in there too. How about creating a memory mapped file? Or parsing a date? Or resolving the IP address of a hostname? Parsing a python string? Running a python expression as a string? Grabbing the caller's call stack? All of these nifty and possibly dangerous features are all covered in this wonderful book.
   
   Normally, I'm a fan of O'Reilly books but O'Reilly's Programming Python (OPP) is disappointingly basic, and you'll quickly outgrow it. I found OPP very unhelpful as a reference for writing large, scientific simulations in Python. In such situations, the data sets are often large, and thus, one must be careful not to gratuitously waste memory with range() when looping over several arrays in the same loop. For example, there is no mention of the xrange construct, which creates a generator object used for incrementally generating numbers over a range. However, it is extremely rare I find an omission in Beazley's Python, and the omission always involves an extremely obscure and uncommon feature.



2. Very concise and precise information. I would recommend for anyone who wants advance book on python for reference and learning.



3. This little book isn't missing a thing! It's extremely well organized; I find it faster to get answers from this book than from the Internet. Can't say that too often!



4. I say Outstanding Reference, because that's what this book is. While there are examples, they are short and concise - this is not a "how to" book (though the introduction provides an excellent overview). Rather, this is a text to keep alongside a book like Learning Python. It's dimensions are smaller than your typical computer book, so it fits nicely on my desk. Also, the index is the best you'll find (Dave actually generated it from a Python script). It's faster than looking stuff up online.



5. I love the book. Use it with Python in a Nutshell. Use the Nutshell as a more comprehensive reference and this book to get exactly what I need when I have a general idea of what is needed. I see Python Essentials as more of a 'nutshell book' than the actual nutshell book. It is clear and concise and I find the print size to be very acceptable. The book is a maverick when it comes to being able to compare different approaches/elements. It will not do it for you, but since it is so precisely laid out, it is easy to think in terms of: "If I used this then I could do this; If I used that then I could do that, but not this, etc." If you have a basic background in python or other language, you will likely be able to frame up your ideas/knowledge into specifics and start coding to learn more or if you are already an accomplished programmer you can check and refine code in progress or established code projects.

No comments about Pragmatic Thinking and Learning: Refactor Your Wetware.

5 comments about The Java Tutorial: A Short Course on the Basics, 4th Edition (Java Series).

1. This book is based on the tutorials available on the Java site, but I found this didn't worry me at all as I read the book.
   
   I have always been impressed with 'The Java Series' of books from Sun and this one ranks well. But while I was prepared to accept a more superficial transfer from the web version, what I got was much nicer. The book includes many important topics that are required to move from 'basic Java' to serious development, and while the collection topics alone is enough to recommend the book, the coverage is a mixture of the basics, advanced, and the "need to know" which impressed me.
   
   The coverage of the very basics is a lighter than in many beginners books so you wouldn't want this to be your only book, but I would certainly recommend it to people who have a grasp of the Java basics, anyone moving to Java from another language, or even if you haven't done much work with Java 5 and would like a decent reference for the additional material.
   
   All things considered, this book has better coverage and more uses to a larger audience than I expected and look forward to having it near me on the book shelf for my future needs.



2. This book is a terrific introduction to the Java programming language. It has been written to coincide with the release of Version 6 of JSE (Java Standard Edition). I had not seen the previous editions of this book, but I was quite impressed with the entirety of this edition. In particular, I really liked the organization. There is a brief chapter that introduces you to the basic recipe of writing Java programs on various platforms, and then the book gets down to business with object-oriented concepts first, before it tackles any other issue. Next it tackles the basics of the Java language specifically - variables, operators, expressions, control flow, classes and objects, and then interfaces and inheritance. This gives the novice an idea of how to do very basic programs in Java that include its object-oriented facets. Next, the more elegant concept of generics is introduced. The book makes it clear not only how to use them, but why you would - they add stability to your code by making bugs more detectable at compile time. Oddly enough, the next chapter is where the author chooses to introduce the creation and usage of packages. This is generally saved to the end of most books, since bundling classes and interfaces into packages is not something that the novice Java programmer needs up front, but it is a well-written and well-illustrated chapter on the subject. Next the author returns to more basic Java topics - numbers and strings, exceptions, and basic I/O. It is hard to do anything meaningful in Java without a grasp of these topics, and the book does an especially good job of explaining the confusing world of Java I/O.
   
   The chapter on the Java Collections Framework is made easier by the previous chapter on generics. The chapter on concurrency is well done, and catches you up to concurrent processing on the Java platform as it exists in Java 5.0 and later. Regular expressions will probably be old hat if you are from the world of Unix scripting, but this chapter does not make any assumptions and explains the concept from the beginning and then how that concept is implemented in Java. Next is an oddly practical chapter on the platform environment that includes issues like system utilities and the PATH and CLASSPATH environment variables that you almost never see published in a book. Usually, you see Swing explained along with exceptions, but since properties and exceptions have already been covered, this makes explaining the complex issue of GUI implementation with Swing a bit easier. The book concludes with chapters on JAR files, Java Web Start, and the ancient topic of Applets, which, after all, is the reason Java was such a hot language in the first place. Appendix B is a handy one on preparing for Java Programming Language Certification, which was not the purpose of this book, but it certainly is a useful tool in this process.
   
   Each chapter concludes with questions and programming exercises to test your knowledge. The book clearly explains each topic, has plenty of good illustrations, and lots of sample programs to illustrate the points being made. If you are a beginning Java programmer, I can't see a better way of picking up the Java language in its most modern form than this book. The following is the table of contents:
   
   Chapter 1. Getting Started
   Chapter 2. Object-Oriented Programming Concepts
   Chapter 3. Language Basics
   Chapter 4. Classes and Objects
   Chapter 5. Interfaces and Inheritance
   Chapter 6. Generics
   Chapter 7. Packages
   Chapter 8. Numbers and Strings
   Chapter 9. Exceptions
   Chapter 10. Basic I/O
   Chapter 11. Collections
   Chapter 12. Concurrency
   Chapter 13. Regular Expressions
   Chapter 14. The Platform Environment
   Chapter 15. Swing
   Chapter 16. Packaging Programs in JAR Files
   Chapter 17. Java Web Start
   Chapter 18. Applets



3. So far I'm on chapter 5 and everything is fine except for inheritance and interfaces I think that the explanations and the examples are confusing, but I do recommend this book.



4. This book is up-to-date and well paced. I recommend it to someone aware of the Java syntax that wants a quick re-cap before getting to the well explained chapters on Classes, Inheritance, Exceptions, I/O, JAR and Java Web Start. On the downside the chapter on collections is a tough read and the last chapter on applets feels like it doesn't belong to the book.



5. This is an excellent book for java beginners. Indepth explanation and easy to understand and learn.

5 comments about Programming Language Pragmatics, Second Edition.

1. Every good programmer should know more than one programming language, that much is almost a consensus. But more than that, every programmer should educate himself about programming languages in general, what they mean and how they work. It's important to know at least the major programming paradigms, because they form the "mental model" of computation that is available to a programmer in a language from that paradigm.
   
   And then it's always illustrative to know about the differences in many common languages, to see where different decisions have been made and what are the consequences. To know that certain legacy languages (e.g. C, Fortran) have features that were not designed because they were the "best" option (for some definition of best), but because the design was constrained by what technology was currently available.
   
   This knowledge is not only required of compiler writers. It should be required of every good programmer. Compiler writers, of course, must know this, and probably in more detail. But Scott's book is a good resource about programming languages, in a level of detail that I believe adequate for all programmers.
   
   There are two main kinds of books on programming languages: they are "survey" and "implementation".
   
   Survey books show how things work in a lot of languages, comparing them along the way. Often the comparison gets down to small details that can affect the meaning, or semantics, of similar programs written in these languages. These books contain one individual chapter for every major topic, and inside such a chapter all languages are compared in relation to the topic. For example, one such chapter covers "subroutines" and then compare a host of different languages on how they implement subroutines.
   
   Implementation books are different: they show how to implement many language features, usually by presenting code for interpreters and compilers. The reader doesn't learn that Ada permits nested subroutines, but instead how nested subroutines really work and how to implement them in a language, for example. A very good book of this kind is "Essentials of Programming Languages" by Friedman, Wand & Haynes.
   
   I normally prefer the implementation books. I'm not really interested if Standard Pascal permits functions to be passed as parameters or not; if I do need to write a Standard Pascal compiler I'll look for a reference manual. I much prefer to know how to implement functions as parameters, and be done with it. Comparing minutiae about extant programming languages can sometimes be very enlightening, and sometimes be mostly dull.
   
   Scott's book, however, really shines because it mixes feature descriptions and implementation details in the presentation. It does the usual routine of comparing a lot of different languages, most of the time the more popular ones like C++ and Java, but it then shows how the implementations differ because of differences in features. The book strikes a good balance between "language design" and "implementation" approaches, although it is clearly slanted towards design, and so more of a traditional "survey" book.
   
   It wins over other survey books by including implementation information about almost every topic, and by the clear writing and style. Also, most survey books concentrate on mainstream imperative languages (nowadays C++, Java, C#) and leave other paradigms to chapters at the end. Scott's book is a bit better in this respect: the presentation often includes Common Lisp, Scheme and Standard ML in the comparisons. There are separate chapters about functional and logic programming too, but considerations about functional programming are spread in the whole book. This is important because paradigms change, and a good programmer must be able to adapt.
   
   It's a good reference for language implementors and good education for most programmers. I look forward to the next editions.



2. As a software engineer, I tend to be picky about my books, but this one is very in depth and a good read. You will learn a lot about different programming languages, and why certain languages are better than others for solving different types of prroblems.



3. This is among my favorite computer science books. I read the first edition straight through from cover to cover, even though I had some prior knowledge of the subject. I have since purchased the second edition, which exceeds the high standards set by the first edition. Scott's book would have made the programming languages course I took as an undergraduate much more enlightening, had it existed at the time.



4. Overall, "Programming Language Pragmatics" (PLP) is a very good book. According to the Preface:
   
   "It aims, quite simply, to be the most comprehensive and accurate languages text available, in a style that is engaging and accessible to the typical undergraduate....
   
   At its core, PLP is a book about how programming languages work. Rather than enumerate the details of many different languages, it focuses on concepts that underlie all the languages the student is likely to encounter, illustrating those concepts with a variety of concrete examples, and exploring the tradeoffs that explain why different languages were designed in different ways."
   
   I'm not knowledgeable enough to pass judgment on "the most comprehensive and accurate" part. But, I'm pretty happy about the book meeting the rest of those goals. I read through the book on my own and have only a few significant gripes:
   
   - Chapters 2 (Programming Language Syntax) and 4 (Semantic Analysis) are tough to get through. They're basically trying to teach enough about Alphabets, Languages, Regular Expressions, Context-Free Grammars, Finite Automata and Push-Down Automata for the reader to understand what the rest of the book is based on. I've read Cohen's Introduction to Computer Theory, which is dedicated solely to this material and I still had some trouble. With an instructor in a class to walk through the things, it should be doable. But, for a person reading the book on his own, ugh.
   
   - All of Section III: Alternative Programming Models, seems to depart from the format of the rest of the book (as noted in the Preface) where the author talks about the concepts and then how the different languages implement them. Instead, he focuses on the languages themselves and almost seems to be trying to cram a primer into his text. Since the section seems to be a special case, it wouldn't be so bad except that the languages covered are a bit out of the mainstream and so that degree of depth gets pretty unreadable at times. Again, with a professor around, things would be better.
   
   - At a more pedagogical level, the author has a tendency to merely explain what his example Figures are doing in general terms. The problem is that a lot of the code/pseudocode involves fairly advanced structures in several languages (many of which most people won't have run across). It would have made things a lot easier if he had walked his way through each of those Figures line-by-line and explained what each line did. Once again, this wouldn't be that much of a problem in a normal teaching environment since a professor could do it.
   
   Other than those three things, this is a very good and readable book. I rate it at four stars out of five.



5. Programming Language Pragmatics 2nd Edition (PLP2e) is a fantastic book that covers a great deal of information. It starts with explaining lexing and parsing, and then goes into scope, target machine instructions, control flow, data structures, a number of paradigms, and building a runnable program. It touches on pretty much every aspect of computer programming, and with deep and insightful knowledge.
   
   While it's not as specific as some other books (language specific references, compiler construction texts, etc), it is a great beginning and reference for a wide range of topics. The bibliography of this book is incredible. I have marked a large number of papers/books from the bib that I now want to read in full.
   
   The bonus information on the CD is also very good, including all the source code from the book, extra sections, and links to other resources.

5 comments about Core Python Programming (2nd Edition) (Core Series).

1. Fellow Programmers,
   I am new to Python and found this book to be a comprehensive source of information. I started off with Java a few years ago in my spare time, however; Core Python is an excellent book for an understanding concepts in OOP for both languages. I thoroughly enjoy the book and the Python Language itself. My only criticism is that most of the programs are short, but from cover to cover; the reader will walk away with a rock solid foundation in python programming.
   
   L.R. Young



2. This book has small snippets of insight, unfortunately they are scattered across over 1000 pages. The book seems to take a general format of: 1) "Here is an idea or concept - not sure why I introduced it now;" 2) "The concept just seems to have a logical grouping with these other concepts;" 3) "But we will not go into the concept or the other concepts now;" 5) "We will save them for another section that will then refer you back to this section as a reference for those concepts;" 6) "By the way, did you know that C, C++, Java, Java Script have this vague similarity of implementation but use this code" 7) "Don't bother that this aside has no value for understanding python (if you are literate in other languages, you will get the similarities and differences - if you are not, then why bother introducing irrelevant material)."
   
   In essence, the book seems to say - I have 1000+ pages to write in, therefore organization and relevancy are secondary to filling them up. Also, there tends to be numerous mistakes in the prose as well as in the code. A trip to the book's website shows that, apparently, it took the author three tries (plus a .diff file) to get the MakeTextFile script correct. There are better books out there (along with the python online documentation).



3. I'm relatively new to Python, having programmed in 'C' and Pascal for many years, and have found this book to be a very good first book to read. As a programmer relatively new to Python I've found that it provides me with very good coverage of the language and its most popular modules. It is not a reference book like "Python In A Nutshell", which I would also recommend. It won't be sufficient if you plan on writing complex GUI applications using wxPython, but there's another good book available for that. Thanks to this book and a couple of others I've been able to produce several useful Python applications. If you're a programmer new to Python, I would recommend this book as one of the first you read.



4. I recently changed my job. My new company uses Python as the main technology. Before starting this job, I didn't know Python at all. The project I worked on was on a tight schedule. Fortunately I got this book and I can immediately starting writing code in Python on the first day. The book is written in a very easy to read and understandable way. It covers almost everything you need to know about Python. The "Core Tip", "Core Note" and "Core Style" sections are especially useful and helpful. They are not just for the Python beginner to develop good coding skills and habits. They are also very valuable advice for the people who already know Python. If you want to learn Python quickly or if you want to expand your Python knowledge, this is a book for you.



5. I got this book because of its many positive reviews, but I'm not happy with it.
   
   I'm a professional programmer. C++ is my main language, but I know C, Java, Perl, Smalltalk. I have used Python a fair amount in the past; I wanted to go through a Python book because I'm starting a new project in Python and the language has changed since I last used it.
   
   My main criticism of this book (2nd edition, 3rd printing) is its sloppy production. It is loaded with typos, broken code, and other errors. I'm surprised that most other reviewers didn't comment on this fact. The author knows about many of these errors and has corrections posted on the web, where he airily excuses the book's errors as being "due to lack of time or priority during the highly-compressed editing phase." If he or the publisher really cared, many of these errors would have been corrected by the third printing. (Many would not require resetting even a full line of type.)
   
   As other reviewers have said, Chun's writing is rather disorganized and conversational. That's not to my taste, but evidently it suits lots of people. For the length of the book, the depth is not great.
   
   Some reviewers say that this is the best book they have seen for beginning programmers. Maybe they are not familiar with Kernighan and Ritchie's classic, _The C Programming Language_. That book, in my opinion, is the standard of excellence.
   
   Overall I prefer Beazley's _Python Essential Reference_ 3rd edition to Chun's book. The Reference is terse and maybe not suitable for a novice, but it is thorough, accurate, well organized, and carefully produced. Chun does provide exercises after each chapter; that is the book's main positive feature, in my opinion.

2 comments about Beginning C# 3.0: An Introduction to Object Oriented Programming (Wrox Beginning Guides).

1. I've read several of Dr. Purdum's books in the past and have always found them informative and enjoyable to read. Beginning C# 3.0, An introduction to Object Oriented Programming (Wrox) is one of his best book yet. As he asks in the introduction, there are dozens of C# texts out there, so why should you pick this one? His answer is that, while most of the other texts were written by extremely capable programmers, few of the authors have never stood in front of several hundred students looking for examples that teach the material yet are easy to understand and remember. Several of the key strengths of this book are the examples and the way Dr. Purdum anticipates the reader's questions.
   
   For example, in covering the OOP concept of encapsulation in Chapter 2, he discusses why programmers hide the data properties of an object inside the object. He states: "You hide them for the same reason that kings used to hide their daughters in the castle tower...to keep other people from messing around with them." Later on, when discussing the difference between public and private access specifiers, he points out that using the public access specifier is like locking the princess in the castle tower and then passing out her room key to all the knights of the realm. I don't know about you, but this is easier for me to remember this than some dry explanation that one often reads on encapsulation.
   
   Another strength is the way he anticipates rough spots for the student. One of the most difficult concepts for beginning programmers is the difference between value types and reference types. Dr. Purdum uses a simple explanation of what a symbol table is to discuss l-values and r-values. He then introduces a concept he developed called Bucket Analogy which uses the symbol table concepts to explain the difference between the two classes of data. Even experienced programmers will appreciate this example and how it truly makes the differences clear. He uses a job interview to explain what objects are as well as cookie cutters to explain instantiation. The book does reflect his 25 years of teaching experience.
   
   The material covered is what you'd expect for an introductory text. He also covers relatively new topics like Generics and LINQ. The database chapter even has a fairly complete DBMS. However, the entire theme is to teach OOP and good coding techniques. For example, he'll write a code example that works but then calls it an example of RDC (Really Dumb Code). He then rewrites the code and explains why it is a better solution, especially when writing for a commercial environment. His objective is to teach you good OOP techniques using C# as the vehicle to learn those techniques. His experience owning a software company for 17 years shows through while doing this.
   
   If you want to get a solid introduction to OOP and C#, choosing this book is one of the best choices you can make.



2. Dr. Purdum brings it home like nobody else does. He is an educator and he knows how to get you to understand the concepts of programming. He uses real world examples to connect your mind to information he is teaching. Now I can honestly say, I get it. Thank you Dr. Purdum.