Programming Books

I have to hand it to Mr. Comer and Stevens, they have done an excellent job writing a book that explains everything clearly with very well defined (and actually working) examples.
If you are interested in learning TCP/IP programming on Unix platform this is the only book you need.
It does assume that you have knowledge of some C programming, but it does not assume that you are an expert.
Excellent Book.

I have been using Internetworking with TCP/IP Volume III for almost ten years now to teach a graduate course on client server programming. I think it is perhaps the most perfect textbook ever written. Comer's code is exquisite and can be used to teach clear and efficient coding in C. His explanations are perfect. He says everything that needs to be said, and no more. His presentation about the foundation of all distributed computing is clear concise and on target. Students require some reminders about the fact that this book can't be read like a novel, or like any less competent textbook. They need to read and carefully consider each line. Comer includes everything that is needed in the book and its appendices. In every case, you see very careful and concise statements of how things really work. I just reread his chapter on NFS this morning and was reminded about how he can take the complex and invisible and make it completely understandable.

Professor Comer's books are wonderful, but his contributions don't stop there. If you pride yourself on writing and are new to the academic realm you might find it useful to go to his website and read his advice on writing a dissertation. If you are a PhD student, or a master's student writing a thesis, this should be a mandatory stop. If you are simply a person who takes pride in writing clearly, you will learn important things.

This is a great book and I see why some teachers chose it for grad students. I didn't do well in networks last semester because I had to learn BSD TCP/IP sockets from sources like book snippets my teacher gave me, man pages, and various Internet sources. The textbook I had to buy for class has almost no C code or any explanations about BSD sockets. So, I invested into this and the Richard Stevens (UNIX Network Programming) book. Both are excellent assests.

Pro (This book): I like how it explained what each important function did (like read/write)

Con: The example code could be a little better.

This book is well-written and will be a good reference once I'm through with my class. I bought all 3 volumes since I could get them at a great price. What especially helped: sometimes books would take up to 50 pages explaining a topic. The "Internetworking with TCP/IP" series are excellent at giving the bottom line and at times makes it easier to understand the details within the longer-winded pages of other books. In a way, to me, it's like a set of cliff notes to my textbook.

If you're baffled about network programming, these books might be worth a try.

Get all three volumes. There is no better way to learn TCP/IP. The read is excellent. The examples are very excellent. Definiirly, a classic for years to come.

I used this book from cover to cover in a Unix Socket Programming class. A few good points about this book: 1) The sample do compiled on Linux with no problems. That's a plus. 2) The author emphasized good client-server design principles. 3) The introduction is gentle and very readble. 4) The code sample is directly,simple and not riddled with unnecessary details to "show off" like some authors do.

You don't need much Unix to do exercise in this book.About the only System calls you need to know are fork(),Select(),sigalarm() and execve(). The book could have been expanded to cover HTTP,SOAP and some other protocols to give it a 5stars.

Exactly as described, fast delivery. I will always try to choose amazon from now on.

This book is THE best LP book I have come across. The topics are very clear and presented in the best possible manner. Introduces you to several basic and advanced LP topics, theorems and algorithms. The exercises at the end of each chapter test the students' understanding in an appropriate manner. A good number of examples are given to explain the theory in a better way. I would definitely recommend this book to a student interested in learning about optimization procedures and/or algorithm development.

Surely helps if you have taken a linear algebra course before. Some students who haven't had a linear algebra course find the math nomenclature formidable in the beginning.

This book is impressive for theory, every thing you ever wanted to know or how to avoid some other is here. I teach to industrial engineering students, so i have to use other books for the application, but for the theory, everything is covered here, even more, in the book are several simple rules to avoid tipical problems of the simplex method or transportation problems, or integer forms. You can't call yourself a pro if you haven't read this book.

Most part can be expressed in a more terse way and with math language. However, the book revolve around using very lengthy sentence to explain, which is not so helpful and clear as expressed with math. It can be condensed to half thickness.

The best part of this book is the first half, where the foundations of linear programming are presented in a clear yet relatively rigorous fashion, accompanied by numerous intuitive geometrical explanations of the abstract general concepts. This approach, supplementing mathematics with graphical insights, works extremely well for this topic.

The quality goes down somewhat, perhaps neccessarily, in the latter half of the book as topics are presented less carefully, and in a somewhat rushed manner in order to cover all of the material the authors decided to include. Given that the fundamentals are covered so well, perhaps this is a fair trade.

The only real negative I can think of is that it's a small crime for professors to create their own publishing companies (Athena only publishes works by a small group of MIT professors) and then still charge outrageous amounts for the books. This would be completely unacceptable were it not for the fact that, unlike most self-published work, this book's production quality is on par with that of the large publishers.

I happen to know C++ and this book is quite useful for learning Java, or at least understanding any given Java program. For each Java construct, the book tells what the equivalent C++ construct is or whether it exists at all. In some cases, it also goes the other way -- for each C++ construct, the Java equivalent.

It also covers some Java libraries and briefly outlays applets. There does not seem to be any coverage of servlets or server-side programming.

As good a reference as it is, it seems to be missing some things, most notably initializations. There are pieces of Java code I've seen something like:

subr1(new Foobar {blah(){foo;} blah1(){bar;}});

i.e., a class (Foobar) is being initialized dynamically before calling a function subr1(). The exact circumstances of initialization of variables and dynamic classes are not covered at all in this book.

Other than that, this book is great.

I picked up this book on a whim, thinking it wouldn't be as good as Java in a Nutshell or Core Java, both of which are excellent books in and of themselves. Surprisingly, this contains a condensed version of most of the information of the above mentioned books. It lacks the extended examples of Core Java, but to a good student and intelligent reader, missing out on a few examples won't break your education.

And like JIAN, there is a good amount of reference material in this book, not with the extended detail of JIAN, but enough to get by most of the stumbling stones one encounters while programming.

As a student, I can only carry so many books in my backpack; when I'm programming in the university labs, I want concise and useful as my qualities. At home, I have my Java reference library (CJ, JIAN, etc.), which I consult when I'm at a quandary; for portability and my lab work, this book is the Swiss Army knife of references, one that I carry regularly, and one that can solve about 75-80% of Java problems I encounter.

I picked up this book on a whim, thinking it wouldn't be as good as Java in a Nutshell or Core Java, both of which are excellent books in and of themselves. Surprisingly, this contains a condensed version of most of the information of the above mentioned books. It lacks the extended examples of Core Java, but to a good student and intelligent reader, missing out on a few examples won't break your education.

And like JIAN, there is a good amount of reference material in this book, not with the extended detail of JIAN, but enough to get by most of the stumbling stones one encounters while programming.

As a student, I can only carry so many books in my backpack; when I'm programming in the university labs, I want concise and useful as my qualities. At home, I have my Java reference library (CJ, JIAN, etc.), which I consult when I'm at a quandary; for portability and my lab work, this book is the Swiss Army knife of references, one that I carry regularly, and one that can solve about 75-80% of Java problems I encounter.

I picked up this book on a whim, thinking it wouldn't be as good as Java in a Nutshell or Core Java, both of which are excellent books in and of themselves. Surprisingly, this contains a condensed version of most of the information of the above mentioned books. It lacks the extended examples of Core Java, but to a good student and intelligent reader, missing out on a few examples won't break your education.

And like JIAN, there is a good amount of reference material in this book, not with the extended detail of JIAN, but enough to get by most of the stumbling stones one encounters while programming.

As a student, I can only carry so many books in my backpack; when I'm programming in the university labs, I want concise and useful as my qualities. At home, I have my Java reference library (CJ, JIAN, etc.), which I consult when I'm at a quandary; for portability and my lab work, this book is the Swiss Army knife of references, one that I carry regularly, and one that can solve about 75-80% of Java problems I encounter.

I picked up this book on a whim, thinking it wouldn't be as good as Java in a Nutshell or Core Java, both of which are excellent books in and of themselves. Surprisingly, this contains a condensed version of most of the information of the above mentioned books. It lacks the extended examples of Core Java, but to a good student and intelligent reader, missing out on a few examples won't break your education.

And like JIAN, there is a good amount of reference material in this book, not with the extended detail of JIAN, but enough to get by most of the stumbling stones one encounters while programming.

As a student, I can only carry so many books in my backpack; when I'm programming in the university labs, I want concise and useful as my qualities. At home, I have my Java reference library (CJ, JIAN, etc.), which I consult when I'm at a quandary; for portability and my lab work, this book is the Swiss Army knife of references, one that I carry regularly, and one that can solve about 75-80% of Java problems I encounter.

The book doesn't teach you Java. It is assumed that you already know Java.
doesn't cover all of Numerical calculus and not all of mathematical proofs but great if you are looking study practical programming with Java.

I recommend this book only if you know Java and have basic numerical knowledge.

This book is an introduction to numerical computing that is both comprehensive and fun. It is not a textbook on numerical methods or numerical analysis, although it shows many key numerical algorithms all coded up in Java. The book examines these algorithms enough that you get a feel for how they work and why they're useful, without formally proving why they work. There are also demonstrations of many of the algorithms with interactive graphical programs. Overall I enjoyed this book a great deal. It is not a beginner's book on Java - you should be a pretty good Java programmer already. Also, you should be at least somewhat mathematically mature for the material past part one. That is, you should have had some Calculus and some Linear Algebra prior to reading the last 3 of the 4 parts of this book. I further describe this book in the context of its table of contents.

Part 1: WHY GOOD COMPUTATIONS GO BAD - Simply copying formulas out of a math or statistics textbook to plug into a program will almost certainly lead to wrong results. The first part of this book covers the pitfalls of basic numerical computation.

Chapter 1 discusses floating-point numbers in general and how they're different from the real numbers of mathematics. Not understanding these differences, such as the occurrence of roundoff errors, and not obeying some basic laws of algebra can lead to computations that go bad.

Chapter 2 looks at the seemingly benign integer types. They don't behave entirely as the whole numbers of mathematics do. Arithmetic operations such as addition, subtraction, and multiplication take place not on a number line, but on a clock face.

Chapter 3 examines how Java implements its floating-point types. The chapter examines the IEEE 754 floating-point standard and shows how well Java meets its provisions.

Part 2: ITERATIVE COMPUTATIONS - Computers are certainly good at looping, and many computations are iterative. But loops are where errors can build up and overwhelm the chance for any meaningful results.

Chapter 4 shows that even seemingly innocuous operations, such as summing a list of numbers, can cause trouble. Examples show how running floating-point sums can gradually lose precision and offer some ways to prevent this from happening.

Chapter 5 is about finding the roots of an algebraic equation, which is another way of saying, "Solve for x." It introduces several iterative algorithms that converge upon solutions: bisection, regula falsi, improved regula falsi, secant, Newton's, and fixed-point. This chapter also discusses how to decide which algorithm is appropriate.

Chapter 6 poses the question, Given a set of points in a plane, can you construct a smooth curve that passes through all the points, or how about a straight line that passes the closest to all the points? This chapter presents algorithms for polynomial interpolation and linear regression.

Chapter 7 tackles some integration problems from freshman calculus, but it solves them numerically. It introduces two basic algorithms, the trapezoidal algorithm and Simpson's algorithm.

Chapter 8 is about solving differential equations numerically. It covers several popular algorithms, Euler's, predictor-corrector, and Runge-Kutta.

Part 3: A MATRIX PACKAGE - This part of the book incrementally develops a practical matrix package. You can then import the classes of this package into any Java application that uses matrices.

Chapter 9 develops the matrix class for the basic operations of addition, subtraction, and multiplication. It also covers subclasses for vectors and square matrices. The chapter's interactive demo uses graphic transformation matrices to animate a three-dimensional wire-frame cube.

Chapter 10 first reviews the manual procedure you learned in high school to solve systems of linear equations. It then introduces LU decomposition to solve linear systems using matrices. An interactive demo creates polynomial regression functions of any order from 1 through 9, which requires solving a system of "normal" equations.

Chapter 11 uses LU decomposition to compute the inverse of a matrix efficiently and reliably. A demo program tests how well you can invert the dreaded Hilbert matrices, which are notoriously difficult to invert accurately. The chapter also computes determinants and condition numbers of matrices, and it compares different algorithms for solving linear systems.

Part 4: THE JOYS OF COMPUTATION - The final part of this book covers its lighter side of numerical computation.

Chapter 12 covers Java's BigNumber and BigDecimal classes, which support "arbitrary precision" arithmetic--subject to memory constraints, you can have numbers with as many digits as you like. This chapter explores how these classes can be useful. You compute a large prime number with more than 3,000 digits, and you write functions that can compute values such as the square root of two and e^x to an arbitrary number of digits of precision.

Mathematicians over the centuries have created formulas for computing the value of pi. Enigmatic Indian mathematician Ramanujan devised several very ingenious ones in the early 20th century. An iterative algorithm supposedly can compute more than 2 billion decimal digits of pi. Chapter 13 uses the big number functions from Chapter 12 to test some of these formulas and algorithms.

Chapter 14 is about random number generation. A well-known algorithm generates uniformly distributed random values. It examine algorithms that generate random normally distributed and exponentially distributed random values. The chapter concludes with a Monte Carlo algorithm that uses random numbers to compute the value of pi.

Mathematicians have mulled over prime numbers since nearly prehistoric times. Chapter 15 explores primality testing and investigates formulas that generate prime numbers, and it looks for patterns in the distribution of prime numbers.

Chapter 16 introduces fractals, which are beautiful and intricate shapes that are recursively defined. There are various algorithms for generating different types of fractals, such as Julia sets and the Mandelbrot set. In fact, Newton's algorithm for finding roots, when applied to the complex plane, can generate a fractal.

I have got hold of this book just recently. This is an excellent book on numerical computing using Java that covers many important aspects in numerical computing. I have been writing numerical methods in Java back in graduate school as well as in my professional career for mission critical programs. I must say this book has addressed many issues that must be taken into account such as machine epsilon, choices of numerical methods for different problems, limitations and precautions in using different data types, etc in Java in which if taken for granted, would produce disastrous results.

Ronald Mak has taken the trouble to explain IEEE floating point standards in a fun and easy-to-understand manner.

Another thing about this book that is worthy of a mention is its great OO programming styles. Codes are also well commented and reader friendly. Overall, it is a great source to learn not just on how to program numerical methods in Java but how to write good OO programs.

The only two bad things I could say about this book is that I should have gotten of this book much earlier and if only Amazon allows a Six Stars rating.

As the author says, last time I looked Java still had the +, -, /, * and % mathematical operators.. though most programmers end up forgetting it lost as they are in the boring, vulgar and repetitive coding of boiler-plate "enterprise" (read "sell sell sell") applications. This book does a very good job of introducing a Java programmer to one of the most fun and interesting powers that Java can offer ... that is playing with numbers and exploring the world of mathematics. Forget (at least for a little while) Servlets, JSP, EJB, and database massaging... and give a look to how you can use your JDK to study functions, solve differential equations, integrals, system of equations, discover prime numbers and admire the beauty of fractals. The treatment of the various subjects is done is sufficient detail to be clear and sound, but without burderdening the reader
with detail and depth best left for more specialized and hard-core texts that the curious reader can explore after this one. Refreshing.

At one time or another, most of us will likely have to write code performing some amount of numerical computation beyond simple integer arithmetic. As many of us are neither mathematicians nor intimately familiar with the bit gymnastics our machines must perform in order to manipulate numbers, we can get ourselves into trouble if we're not careful. Luckily, "Java Number Cruncher" comes to the rescue.

This book is an introduction to numerical computing using Java providing "non-theoretical explanations of practical numerical algorithms." While this sounds like heady stuff, freshman level calculus should be sufficient to get the most out of this text.

The first three chapters are amazingly useful, and worth the price of admission alone. Mak does a fine job explaining in simple terms the pitfalls of even routine integer and floating-point calculations, and how to mitigate these problems. Along the way the reader learns the details of how Java represents numbers and why good math goes bad. The remainder of the book covers iterative computations, matrix operations, and several "fun" topics, including fractals and random number generation.

The author conveys his excitement for the subject in an easy-to-read, easy-to-understand manner. Examples in Java clearly demonstrate the topics covered. Some may not like that the complete source is in-line with the text, but this is subjective. Overall, I found this book educational, interesting, and quite enjoyable to read.

My knowledge of Oracle and Java is beginner/intermediate level and I like this book a lot.

The book explains how SQLJ relates to SQL, PL/SQL, Java, JDBC and it provides a good introduction to the JDeveloper IDE (Integrated Development Environment).

The book is written very clearly and the appearance and organization of the text is well up to the O'Reilly standard.
I can't comment on the worked examples yet as I have not yet tried them out.

This is just an easy read with good code examples. It is geared toward the intermediate or beginner programmer, and presents clear explanation for easy understanding.

This is an outstanding book. SQLJ is a simpler way of embedding SQL statements in a Java programming, and is possibly the successor to PL/SQL.

I liked this book because it covers SQLJ programming, as well as:
1. Oracle SQL.
2. Oracle PL/SQL.
3. Oracle JDeveloper.
4. Developing J2EE components for the Oracle9i Application server (9iAS) such as EJB, servlets and JSP.
5. Java stored procedures.

I liked the author's writing style: it is clear and to the point. I found it very easy to read, and was able to follow the examples in the book and apply them to my own programs.

I highly recommend this great little book!

This is a great book if you are interested in building J2EE applications and want to link to an Oracle database but don't want to learn the complicated JDBC API. It isn't an 'intro to programming' book like so many out there; it is, however, perfect for object-oriented programmers who are wanting to learn java with a quikness. Finally, a great SQLJ book has emerged!

I found this book to be concise, to the point, and very readable. A large amount of material was well presented in a relatively small amount of space. And the examples worked as advertised.

I found myself incorporating the material presented into my work before I finished reading the book.

An excellent resource.

Mr. Ulrich has delivered a framework with which IT areas can effectively leverage their existing applications and data to meet the ever-changing business environment. Bill's chapter on Case Studies provides real life examples of how to use his methodology. We face rapidly changing business drivers, including the need to make our businesses internet-ready. This book provides the materials to allow companies a fighting chance to succeed.

I read Bill Ulrich's book and was delighted to see that he was clearing laying out strategies that we were dealing with as we worked with our clients. We now make Mr. Ulrich's book part of our mandatory reading for our consultants and have purchased copies for distribution to some of our key clients. This has helped both our consulting teams and our clients in planning and project executiion.

Mr. Ulrich understands how businesses have a tremendous reliance on legacy systems. Pressure is always on the IT staff to meet the demands of the business cusomter. The IT community is asked to bring products and services to the consumer through the internet while managing the internal demands to keep expenses under control. Bill's book lays out a framework in which the business community can build company-specific plans to leverage their prior investments while striving to meet today's business drivers in a manner that is cost effective.

Bill has filled this book with tremendous value for any one working with existing systems of any kind. He builds in the flexibility of approach by mapping many common and not-so-common methods and strategies through his exploration of specific case studies. Chapter 3 is a valuable item on its own - rarely have I seen such a thorough and clear examination of all the different 'movements' in IT in the last 10 years. Nice job, Bill.

Corporations have been trying to retire legacy systems for the past couple of decades. Each new technology (be it client/server, ERP packaged apps, etc) were supposed to put the nail in the coffin for legacy systems. Yet, legacy systems continue to thrive despite attempts to retire them. One reason why they continue to exist is that in many instances, they support business processes in the most efficient and cost-effective manner possible. Bill's book views this area more as a transformation effort (evolution) rather than wholesale legacy replacement (revolution). This book is a must read for IT departments as they struggle to remain relavent in an era of outsourcing.

The strategies outlined in this book will help the IT department become a partner with functional business units in delivering solutions that address burning business problems. The focus shifts to providinig measurable value to the business as opposed to implementing unified and elegant technologies.

From beginner to expert this book contains all of the answers to your lingo needs. It is packed with examples and thorough descriptions.

I can't find an updated version of it - if anyone knows of one please let me know!...

This book has got to be the best computer related book I ever bought. I wish there were reference books in this format for every other programming subject like Perl and JavaScript. It's the only book you will ever need for Director's lingo.

The thing I like most is having the Lingo grouped by subject, it makes things so easy to look up.

Darrel, please make a reference like this for Perl!!!!

If you are already familiar with the Director interface, and want to do things in Lingo that most people only wish they could do, pick this book up right now! This is the only book I use on a daily basis for quick information. Darrel Plant not only gives a clear explanation on every command but also gives you examples that you can understand and use in everyday applications. I also greatly appreciated the way that the book content is organized. Rather than list the commands in alphabetical order, they are grouped according to the type of element or function that they control. It's nice to put something together that the user/client likes, but use this book and they will be saying, "Awsome! Love it! Wow, how did you do that?" ------ Thanks Darrel

...your life will be easier if this book is within reach. I even take it with when I have to go on-site to a client. Very useful having the Lingo grouped by subject. Also very useful icons by each Lingo word showing if it can be used in Shockwave and which versions of Director it can be used in. A must-have for a Lingo programmer.

(excuse my english, I'm Swiss) Before purchasing this book or even knowing about it, I had some heavy problems in finding the right way (or a shorter one) to solve several problems in programming Multimedia-applications. I ordered this book and everything changed! It's descriptions are so easy (even when you aren't originally english-speaking!), because you just can read the text and know what the command, keyword, property a.s.o. is all about. You have even more than one solution showed in examples. There is only one bad thing: if you use this book very often, the cover of the book looks old soon; it could be a little stronger. My suggestion: if you suffer a headache from studying and controlling your non-functioning scripts, you better get this book as soon as possible and keep it handy! You will gain a hell of a time!

Have fun

Best regards

Patric Simon

There are a lot of IT guides out there but this is the one I can't do without. Superbly written, thorough and easy to follow. The labs are also invaluable and turn the words into real knowledge. I highly recommend this book for any IT professional's collection.

70-640 is a breeze after using this book just finished all of my certifications and this book made the 70-640 exam easy. I would recommend this book to my co-workers, friends and strangers alike. If you are prepping for the 70-640, this is all you will need to understand the content and pass the exam. The authors of this book knew how to gear the content to make it easier for you to understand and pass the exam.

This book is absolutely outstanding! They way the authors break down each section and give real world scenarios make this book unique. Given the changes in Server 2008 this book is a must have if you wish to pass the 70-640. After reading this book and using the CD I have passed the test and I know it was because of this outstanding book! I highly recommend this book if your goal is to pass the 70-640 while still obtaining a firm grasp on each concept.

The writing and delivery styles of Will Panek will grab and hold your attention throughout this book. Windows Server 2008 introduced numerous changes over 2003 and the author does a fantastic job of using real world scenarios and examples to teach them to you. Mr. Panek inserts humor in appropriate situations to keep your attention and make a point. If you complete this book you will pass the exam. I look forward to more from this great author.

Just completed my MCSE 2K3 W/2K8 Upgrade, and can honestly say that it would not have been possible without this book! Easy read with great insight!! Dave Morrisette

You can just feel, behind this book stays huge experience. Well written, CD is very handy and I am happy to have this book

This book is very well written. It really tells you what you need to know when using AD. Another great Sybex book that made the 70-640 exam easy!

I am a .NET developer (MCP).

I bought this book because our company launches a new dev project for providing alerts to customers on their financial data (wires, etc.), and I've read that SQL NS is way better than any custom app.

First of all, now that I've read most of the book (and worked through all the samples), I totally support that info.

Secondly (yet very important), I swear I have never had a technical book that was as easy to read and comprehend as this one!
Microsoft is inclined to use some sort of "bureaucratic English" on MSDN, which is a pain in the neck to understand for someone like me (apparently, English is not my native language).
However, even though the author is a Development Lead for SQL NS at Microsoft, his book is as easy to read as my favourite science fiction books (and far easier to read than most of fantasy books like those by Tolkien).

The examples in this book lead you from the most basic concepts of NS to the most advanced features such as developing a custom delivery protocol or a custom standalone event provider.
All you need to start with it is basic knowledge of T-SQL (or, just any flavor of SQL) and XML (REALLY basic!).

And, yes, it's true, you can build a fully functional prototype in less than 2 weeks. I did.

It's a pity that the maximum number of stars is 5.

This book is truly a masterpiece.
A must-have for everybody working with data-driven applications.

It's 600 pages of "SQLNS as a way of life", from beginning to end. It explores setup (without any gratuitous screen shots of setup, THANK YOU), configuration, programming instances and applications, writing the processing configuration files, the subscription management application. There are chapters about custom event providers, formatters, and delivery protocol; there is an example of each. But of course, where this book shines most (is shine most the correct construct? hmmm...) is in the description of internals, tuning, and troubleshooting. That's where it's invaluable. I still remember going over "quantum theory" and all its permutations when I read that chapter.

If you use SQLNS as a notification application framework, it's very easy to get a first instance working, but when your app gets popular and you need 10 more just like it immediately, working with SQLNS quickly becomes all-consuming, that's what I meant by "SQLNS as a way of life". If you're looking to "check out" SQLNS or see if its "right" for your application that's fine too, the preface even gets you quickly up to speed on the SQLNS lingo. I also remember Shyam writing to me a few times about the "its not a custom delivery channel, its a custom delivery protocol". In any case, there's *no way* you can be dissapointed with this book.

This book has been very well written and covers all the aspects of Notification Services a developer must know about. Not only are the various concepts explained very well, the numerous examples and code samples given make this an easy read as well.

One of the key sections of the book is how to troubleshoot your NS application which is the USP of this book, seeing that such treatment to that particular area has not been given anywhere else.

I would strongly recommend this book to anyone who is interested in developing NS applications.

This is a book well worth reading from beginning to end, from preface to appendix. I have done so twice, with the result that I have learned SQL-NS well enough to explain its concepts and architecture to my teammates and higher-ups and to embark upon design and development of notification apps of my own. Mr. Pather puts mastery of this platform within your reach. His pedagogical approach is exemplary, for its organization, pacing, clarity, style and tone. And he covers absolutely everything you need to know about SQL-NS. I wish every computer book out there were written this way.

I would highly recommend this book for anybody developing Sql Server 2000 Notifications Services applications. This book fills the gaps in the Books Online, which, for a large scale application are very important.

The book is structured to provide quick, step-by-step implementation instructions as well as detailed explanations of the hows and whys of Notification Services.

I was particularly grateful for Part III of the book that details optimization, deployment and administration requirements.

Another invaluable part of the book is the chapter on setting up your development environment. I had to do my first application before the publication of this book and I will tell you that had I had this book then, the time I would have saved would have paid for the price of the book many times over.