5 comments about Programming Microsoft Visual Basic 2005: The Language (Pro Developer).

1. Visual Basic appeared more than 15 years ago as a tool to define quick prototypes and develop GUI applications with ease. Its development environment, which the language was literally blended in, was remarkably easy to use. I remember those good old days when a fellow colleague of mine showed me how to draw VB forms and in less than an hour after I was already developing a new GUI application.
   
   Visual Basic has gone through a long way since then. The language is nowadays a powerful, complex, potent medium to develop sophisticated applications. In fact, Visual Basic.NET is virtually on par with C#.
   
   "Visual Basic 2005: The Language" by Francesco Balena tries to show - in a gentle yet dense manner - the long way that VB has pursued over the years and well as the current state of affairs. It succeeds on both counts.
   
   The book is divided in four bigs parts:
   1) The Basics - which introduces the reader to what Visual Basic.NET is all about, with explicit references to the differences between VB6 and VB.NET (very useful for VB6 programmers).
   2) Object Oriented Programming - which presents the OOP support in VB.NET. This section is important because VB.NET departs from the old OOP support and gets more in line with the .NET paradigm.
   3) Working with the .NET Framework - which may be seen as a natural continuation of the previous part in the context of the .NET framework.
   4) Advanced Topics - which tackles how advanced .NET elements (like attributes) get handled in VB.NET as well as what VB.NET is still better than, say, C# (namely the interop with COM and Automation).
   
   The book is truly monumental in form and dense in content. The style is slightly verbose but this adds value: you cannot skip pages without losing valuable information and in such conditions reading a book of this size is quite a task.
   
   As an added bonus, the author presents several mini-projects that are in fact mini how-to tutorials: how to build a plug-in for WinForms, how to develop a n-tier application. Without the generosity of Mr. Balena you'd have to buy an extra book for an introduction in such useful stuff.
   
   "Visual Basic 2005" has several minor drawbacks, though:
   1) The remarks showing the differences between VB6 and VB.NET are scattered throughout the text. For a VB6 programmer this is difficult to follow and for a non-VB6 programmer this is slightly annoying. Perhaps Mr. Balena should have dedicated a special chapter to those differences and then forget about them.
   2) The book does not say much about all the other .NET languages, as if VB.NET is the only .NET language under the sun. In fact, .NET diminishes the differences between languages without making them identical. This is not apparent from this book.
   3) The book does not say enough about what is specific to Visual Basic, besides syntax. Why would anyone want to program in Visual Basic.NET when you have C#? In my opinion, Visual Basic.NET is not going to go away any time soon especially because it retains those qualities of VB6 - a verbose and intuitive syntax, a loose typing system (perfect fit for Automation interop) as well as a slightly better exception catching mechanism. In my opinion, "Visual Basic 2005" does not elaborate enough on such necessary topics.
   
   Overall, the book is a must if you want to come up to speed with the Visual Basic language after years of programming in other languages. However, if you want to learn Visual Basic from scratch or if you want to use Visual Basic.NET for more "mundane" tasks - such as building WinForm applications - then this book is not for you.



2. The things I like about this book are that the topics it covers are very well done. It covers some of the trickier aspects like threading and regular expressions. Being an experienced programmer I like the fact that you can jump around in the book to just the aspects of the language that you are interested. I will warn the novice programmer that this is probably not a good starter book, but if you are ready for the material you will find that it has a good balance of code examples, and explanation.
   
   There are just a few spots in the code example where I can see a slightly better implementation, but if you are an experienced programmer this will not be difficult at all to see yourself.
   
   Last but not least, the appendix is one of the beefiest one's I have seen in ANY programming book. If there is anything I hate about tech books is a lousy appendix and this one is top notch.



3. I made an international request for this book and in the ship info they told me that the delivery of this item would be delayed... but it didn't. i got this book sooner than expected.
   
   it was a geat thing that i got this book before the estimated delivery date!!
   
   thanks
   amazon



4. I had a case dealing with Version Tolerant Serialization, after searching the web; they all came up short. I double checked the book later, and found the answer I needed. That 1 time more than paid for this book.



5. This is a great book.It has a lot of techniques that you would not normally use in your day to day programming tasks.It covers the language properly. Every chapter has actual code that works and that you could use in your projects.The author is definitely a master, and this book proves it.
   The book helped me to pass the MS Exam 70-536, .Net Framework 2.0, Application Development Foundation. Most of the exam topics are covered in it.
   The organization of the book is good, starts with the basics, slowly going to advanced topics.However I think this book is definitely not for beginners, they will get lost in some chapters.
   Overall, I give it 5 stars, it is a great book, well written, well organized, a great reference that every VB programmer should read and have it on their shelf.

5 comments about Service-Oriented Modeling (SOA): Service Analysis, Design, and Architecture.

1. I typically don't write book reviews, and when I write them, I do so for books that I love and appreciate. However, the amount of undeserved praise this book got is ridiculous. Someone has to say the emperor is naked. I am an enterprise architect, and I am knee deep in my company SOA implementation. The good positive comments this book got, made me buy it in a heartbeat, and I was looking forward its arrival in order to help me understand and solve some of the problems any enterprise architect have when building an SOA system. Unfortunately as Gerturd Stein once said about Oakland, California: "there is no there there". As an enterprise architect I could have learned the same amount of information I learned reading this book by spending the same amount of time watching the cartoon network. Honest. There is nothing here really. The emperor is naked. Don't waste your money. I would get SOA in Practice: The Art of Distributed System Design by Nicolai M. Josuttis - although it doesn't explicitly address modeling it is still good enough to get you an overall view of SOA. Or get Enterprise SOA by Dirk Krafzig and others to have a more in depth SOA book. This is not my opinion alone, my other colleague who is much more seasoned architect than myself has the same opinion. You have been warned. Browse it first before buying it. And if you are going to give me a negative vote on was this review helpful, then please write a comment to show why I am wrong, and what are the tangible things you learned from this book.



2. I'm an enterprise architect (a former developer), working for one of the largest retail companies in the US. This book is one of the most important books in the software modeling field because it explains and provides examples of a service development lifecycle. This text demonstrates the power of service reuse via hundreds of drawings and charts and it also offers a language for modeling enterprise applications and services.
   
   My company embraced this book as our SOA modeling bible and most of our architects and developers found it valuable to their daily work. With the offered SOA language we are able to describe integration and deployment of services and middleware and we are also able to analyze our business motivation and the technical feasibility.
   
   This book is necessary to my work, and to many of IT professionals, because it discusses the core of SOA development and it proposes service development ways in the following topics:
   
   1) Service Analysis
   2) Service Design
   3) Service Architecture
   4) Service Typing and Profiling
   5) Service Conceptualization
   6) Service Integration
   7) SOA Integration
   8) Business Integration
   
   Very recommended
   
   Sandra Bernstein
   White Plains, NY



3. It would be nice if we all recognize that SOA is not WS*. The problem with almost any book that claims that it is about service oriented architecture - is actually about web services. The industry fails to recognize that web services are really a very small part of SOA. But the amazing issue is that almost any company vastly capitalizes on WS. In other words, companies typically do not invest in strategies. They construct WS, deploy and integrate WS infrastructure, and create a WS environments. But where is their SOA?
   
   This modeling book gives an opportunity, a rare chance to reconsider what actually we are spending our money on. It comes down to a rudimentary selection between the bottom-up approach, where web services are launched to satisfy tactical concerns; or a most strategic, a top-down choice, that advocates reuse, encourages efficiency, and more.
   
   Recently, the development of simpler service technologies confirms this book's assertion that a service is not only WS. Meaning, a service can be any software component that exposes interfaces to its potential consumers. REST for example, also known as Representational State Transfer, devised by Roy Fielding early in the game, enables developers to avoid the convoluted WSDL (a rigid and tight contract) and utilize a looser service contract approach. As a side note, I would volunteer: it would be astute not to bet on WSDL as a "forever technology". Developers always complain about the WSDL method because it is complex, error-prone, and time and resource consuming.
   
   But the most compiling reason why anyone would want to read this book would be the large amount of new approaches to service design and architecture. It is a serious discussion about the "why" and later it proposes the "what". It is about the "thinking" process first, then the "doing" process next. In essence, every architect and developer that follows this book's advice becomes a strategist that can see the big picture, by learning how to avoid the silo mentality that has driven many of our decisions.
   
   I would give it a four star because it is too long and very detail. Almost every book part can be expanded into a separate book.



4. Before I purchased this book I was skeptical about its promise. I'm not a big fan of big title books or publishers' promotions.
   
   But this SOA modeling book is unique. It makes sense. It is logical. It is one of the best software modeling books that I have read. I think that it is big in historical proportions.
   
   A big part of it is a software development methodology. It is kind of a step-by-step guide to developing services. This is a guide for developing software on the application/service level and on the enterprise/service level.
   
   The other sections introduce a modeling language for service oriented architecture. The two authors explain and justify service reuse, service composition, decomposing, usage of SOA intermediaries, usage of ESBs, usage of SOA Gateways, usage of Adapters, and business process modeling.
   
   The book itself includes examples and diagrams for modeling but you can find more examples on different sites on the Internet.



5. This is an exceptional personal and collective guide for professionals that are lost in the SOA space - just like me. This is especially good for understanding how services can achieve business objectives and IT needs. It is also great for software development and developers that want to know how to analyze and design services for production. In addition, architects will love it. The most impressive aspect of this book is the SOA methodology that it addresses. It looks like this is the only book on the market that tackles the modeling niche in SOA and I think that it will be a cornerstone for all books that will be written about software modeling thereafter. Great read, good ideas, and fun.

1 comments about Beginning XML Databases (Wrox Beginning Guides).

1. I work with a lot of school leavers and people outside IT and often have to advise them on how to empower themselves in IT in the right way. Surely SQL and databases are one of the first topics people should understand. HTML was also high on the list. With this book, the author has combined all of them in one making it a very relevant combination for today's beginner. I will recommend this book to school leavers, financial people and people outside IT wanting to empower themselves quickly. Another great advantage of XML and databases is the platform independence. Very well done to the author for combining these topics at the entry level in such an easiliy understandable way!

5 comments about Beginning JavaScript, 3rd Edition (Programmer to Programmer).

1. Still the best book on JavaScript. With each edition it becomes better, if that's possible.



2. I have used the first and second editions of this book as training courseware for several years. Allthough, I was never 100% happy with the book (some important topics had been left out, the content is not cleanly organized and the examples could have been better) it served its purpose.
   
   When I heard that the 3rd edition would be coming out, I looked forward to new and updated information, more complete descriptions and the inclusion of previously omitted information. When the 3rd edition came out, I purchased it and found it to be VERY DISSAPOINTING...to the point that it is actually worse than it was before. I will no longer use this text as a training resource as it is more conveluted than in the past and still does not include basic information that should be there.
   
   Examples:
   
   The 2nd edition was 1010 pages, the 3rd edition is 767 - clearly much information has been removed and unfortunately it was Appendicies B, C, & D, which were The JavaScript Core Reference, The JavaScript Client Reference, and the Latin Character Set. Now, the book just has Appendix A, which is the book's exercise solutions. The book's exercise, by the way, is a continuing example that is not very "real-world" oriented and something that most people would skip over anyway. Devoting an appendix to this, but removing the hard-core reference appendicies makes no sense whatsoever!
   
   In none of the previous editions was there any mention of referring to external script files (.js) files, as is done as common practice out in the real world. I was hoping the new edition would include this, but not a word about it is mentioned.
   
   The confusing "flow" of the chapters has not been corected, so you still have to get to chapter 10 before addressing errors and debugging techniques (which should be addressed as chapter 2, in my opinion as a professional trainer) and finding out that you really should be working with certain IE and FireFox settings changed if you want to be able to see your JavaScript errors show up in your browser! Seriously?! The reader is expected to go through 9 chapters without being told how to see an error message about their mistakes!! Like we don't make mistakes until chapter 11?!!
   
   Chapter 13 is still called "Dynamic HTML in Modern Browsers" instead of what the rest of the world calls it; "The W3C Document Object Model".
   
   There was, and still is, a chapter on XML in the book, but rather than simply merging this information into the chapter about the DOM (since the only JavaScript that is discussed in the XML chapter has to do with parsing XML via the DOM), we get a small chapter that is more about XML than JavaScript. And, there is no mention at all about using JavaScript within XML, rather than XML within JavaScript (ie. enclosing JavaScript inside of CDATA sections for proper XML parsing).
   
   We still have the same old chapter 4 that is an overview of JavaScript and OO. Half of what you need to know about the JavaScript Native Objects (String, Number, Math, Date, etc.) is in this chapter and the other half is in chapters 8 and 9, instead of putting it all together in one place.
   
   The bottom line for me is that this book skips important information that new JavaScript developers should know. It has no hope of becomming organized properly and crucial appendicies have been removed. This makes this book no longer useful as a reference (which serious programmers want and need).
   
   By the way, WROX (now owned by Wiley Press) has done basically the same thing with the new 4th edition of Beginning XML. That book is still wildly incomplete and disorganized.



3. I bought this book for a class I was taking and it help me to better grasp the the subject of JavaScript with it's practical examples and quizzes. I am a better programmer now. I can't wait for their Advanced JavaScript book if there is one.



4. I was required to purchase this book for a class that I was taking. It works well for the class, and I feel that the content has been thorough. The explanations have been very good.



5. With this up-to-date guide, you'll find everything you need to know in order to develop interactive, robust, and personalized pages using JavaScript. It takes you step by step through this powerful scripting language so you can begin enhancing your site right away and increase visits. You'll learn how to take advantage of native JavaScript objects, manipulate objects that are available to you in the latest browsers, use cookies, and jazz up your web pages with Dynamic HTML. Great Update!!!
   Table of Contents
   
   Chapter 1. Introduction to JavaScript and the Web.
   Chapter 2. Data Types and Variables.
   Chapter 3. Decisions, Loops, and Functions.
   Chapter 4. JavaScript--An Object-Based Language.
   Chapter 5. Programming the Browser.
   Chapter 6. HTML Forms--Interacting with the User.
   Chapter 7. Windows and Frames.
   Chapter 8. String Manipulation.
   Chapter 9. Date, Time, and Timers.
   Chapter 10. Common Mistakes, Debugging, and Error Handling.
   Chapter 11. Storing Information. Cookies.
   Chapter 12. Introduction to Dynamic HTML.
   Chapter 13. Dynamic HTML in Modern Browsers.
   Chapter 14. JavaScript and XML.
   Chapter 15. Using ActiveX and Plug-Ins with JavaScript.
   Chapter 16. Ajax and Remote Scripting

5 comments about Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers).

1. Venkat does a fantastic job of explaining what Groovy is, how it evolved, why you would want to use it, and how to integrate it with your Java projects.
   
   He has a fantastic sense of humor, which really shows through in this book. If you ever get the opportunity to see him speak, take it. He's an incredibly intelligent, articulate programmer, and probably the most language-agnostic programmer I've ever met.
   
   One caveat: if you are a Java zealot, this book may send you into little fits. In the first section of the book, he converts standard Java code (groovyc can compile most Java code, so it's actually Groovy code that looks like Java) into Groovy. There are a lot of comments that may make Java zealots throw little fits.
   
   If you're stuck using Java, get this book.



2. Overall, a very good book on Groovy. Great simple examples to work from. I was very impressed with the chapter on Closures which can be a difficult subject for those coming from primarily a Java background. Wanna learn Groovy? Get this book. [...]



3. With 'Programming Groovy: Dynamic Productivity for the Java Developer', Pragmatic has quickly become THE choice for Groovy and Rails resource books on the market. This book is another fine release in the Groovy set of books (Pragmatic has released a few previously) and I can easily recommend this if you program with Java + Groovy.
   
   **** RECOMMENDED



4. I can't add much more to Neal Ford's great comments but I just want to say that I also am truly enjoying Venkat's book. I have seen him and Neal in several NoFluffJustStuff conferences and this book honors that tradition. He does a great job at introducing language features without any unnecessary stuff.
   
   I started reading his beta copy in PDF from the Pragmatic Bookshelf and being relatively new to Groovy I now feel quite a bit more prepared to tackle problems that are difficult and a bit clunky with Java. I suddenly feel like I have a chance of doing some of that 'cool stuff' that the Python and Ruby dudes are always bragging about.
   
   Thanks Venkat!



5. Groovy - it's not the philosophy of the 1960s, it's a programming language, and a good one too. "Programming Groovy: Dynamic Productivity for the Java Developer" is a thorough and educational guide to this programming language, which can bring developers many things they need and want to do in their programs. With tips on how to effectively mix both Java and Groovy, and with plenty of advanced programming techniques, "Programming Groovy: Dynamic Productivity for the Java Developer" is a top pick for community library computer collections and for any Java programmer.

No comments about Introduction to Programming Using Visual Basic 2008, An (w/VS2008 DVD) (7th Edition).

5 comments about Programming with POSIX(R) Threads (Addison-Wesley Professional Computing Series).

1. I had no knowledge of thread programming before this book. With this book, I was able to create several multi-threaded socket communications programs.
   
   One of the important things the book omits when discussing non-reentrant functions is that fopen() is not re-entrant (I discovered this when 4 threads received the same FILE* pointer). Another interesting issue is how files are initially created as -r--r----T. If the thread dies withouth having issued a close() or fclose(), the file cannot be overwritten without first explicitly being removed. If the file is closed, the permissions are properly adjusted.
   
   Because it is so difficult to debug threads, I feel more attention should have been given to the subject.
   
   One of the great pluses of this book (actually, of pthreads) is that I did not have to recode anything when converting to nptl (other than the include becoming "nptl/pthreads.h").
   
   This is the only thread programming book I have ever read, so I cannot compare it to anything else (yes, Steven's UNPv1 briefly mentions threads, but that is not the focus of the book). I can simply attest to the fact that before having read this book, I could not do thread programming, and now I can. The book clearly served its purpose, and I still use it as a reference.
   
   The illustrations with the old guys really weren't of any help, and what's up with all the Lewis Carroll quotes?



2. Pros:
   
   - Understandable language
   
   Cons:
   - Need better explanations though.
   
   Overall, okay for the price, if you arent looking for too much.



3. I've been using this book as a reference for Pthread programming for the past 2 years. The thing that strikes me most about this book is that it *always* has the answers to my questions, and those answers are always easy to find.
   
   A couple of examples. I was thinking to myself "Wow, if the thread was to be cancelled while these set of operations were executing, things would be very broken. How do I make sure these operations get executed in full?"
   
   So, I went to the index and looked up 'Cancellation', under which there was 'deferred', which pointed me to pages 147-150. Right on the top of page 147 it says "A thread can disable cancellation around sections of code that need to complete without interruption, by calling pthread_setcancelstate." It then goes on to give examples. I thought to myself "That was easy!"
   
   Another example, I wanted to know how to protect a local static variable from multiple simultaneous initialization. I looked up 'Initialization' in the index, which pointed me to pages 131-134. Sure enough, on page 132 it says "If more than one thread executes the initialization sequence concurrently, two threads may both find 'initializer' to be 0, and both perform the initialization, which, presumably, should have performed only once. The state of initialization is a shared invariant that must be protected by a mutex. You can code your own one-time initialization using a boolean variable and a statically initialized mutex. In many cases this will be more convenient than pthread_once, and it will always be more efficient."
   
   Wow, another clearly explained answer to my question. I could give another example regarding how to properly use condition variables and avoid subtle race conditions, but suffice it to say the answer was easily located and clearly explained. If only more books were this accessible!
   
   Is this book suitable for an expert Pthreads programmer? I don't know; I'm not that person. What I do know is that I have to write Pthreads code that is correct and reliable, and this book gives me the advice I need to make that happen.
   
   Mr. Butenhof, could you please write more books on POSIX programming?



4. In my opinion, this book is better than Pthreads Programming: A POSIX Standard for Better Multiprocessing (O'Reilly Nutshell) because it goes way beyond just presenting the pthreads API. One critic I had on all the other multithreading books that I have read is that they are not covering issues with multithread programs on a SMP system. This book is actually discussing some of these issues on several pages! Beside this quality, it also covers high-level design patterns on how you can use threads such as pipelines, work crew and client/server. There is also a chapter showing how to program with thread cancellation and a section explaining how to create new synchronization objects from the primitives. This brings me to the only problem that I can think of this book: its age. It is not totally up to date. Learning how you can build new synchronization objects by itself is a very interesting exercise but the problem is that the new synchronization objects built are the barrier and the read/write lock which have been added to the pthreads API since the book publication. Also, except for a small section describing the futur of pthreads, the newest additions to the pthread API are not described.



5. I first read the book about 6 years ago (2003) when on my MSc studies. A friend lent me the book to read as a basic introduction for thread programming. At that time I was doing projects in Java only, but surprisingly it was so easy to understand Java thread model by reading the book with code samples in C.
   
   Two years later, I stayed on PhD studies at the University. Once again I needed to do some parallel processing project. I ordered the book through my library. Once again it became handy. But it still wasn't on my bookshelf - I had to go to the library to have it.
   
   This year I said to myself: 'No. If you needed this book so many time, you got to have it on your bookshelf'. So there you go - I bought it as a gift for myself for Christmas 2007.

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.

3 comments about Professional Windows PowerShell (Programmer to Programmer).

1. This book is extremely well written and easy to understand coming from a non or limited programming background. If you are completely new to programming, I'd suggest reading Microsoft Windows PowerShell Programming for the Absolute Beginner by Jerry Lee Ford Jr. first and then read this book. Also, so far the code has been exceptionally accurate, which makes the experience that much better.



2. This is a really good book. I have purchased a bunch of other books on Powershell but most of them were written with developers in mind and not system administrators. Well good news, this book is written specifically for Windows System Admins. It walks you through how the scripting language works (.NET), and it provides very clear examples of how to use and create power shell scripts. With this book in hand and the free information that is available on the Microsoft Technet site, you are on you way to becoming a proficient Power Shell Scripter! Well done Mr. Andrew Watt.



3. I purchased this book based on two previous reviews and so far I'm somewhat disappointed. For example, I think the author should include how to add comments to a script (e.g. #) early on in the book because adding comments is proper coding practice. Also, none of the author's sample scripts include comments either. Additionally, I find the sample scripts to be very simplistic short examples and I defiantly expected to see far more complex sample scripts that demonstrates the more advanced scripting capabilities of the PowerShell scripting language. Based on this, I'm surprised that this book is in the professional series because what is presented in the book is at an introductory level.

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.