Product Description
A hands-on introduction to parallel programming based on the Message-Passing Interface (MPI) standard, the de-facto industry standard adopted by major vendors of commercial parallel systems. This textbook/tutorial, based on the C language, contains many fully-developed examples and exercises. The complete source code for the examples is available in both C and Fortran 77. Students and professionals will find that the portability of MPI, combined with a thorough grounding in parallel programming principles, will allow them to program any parallel system, from a network of workstations to a parallel supercomputer.

* Proceeds from basic blocking sends and receives to the most esoteric aspects of MPI.
* Includes extensive coverage of performance and debugging.
* Discusses a variety of approaches to the problem of basic I/O on parallel machines.
* Provides exercises and programming assignments. ... Read more

Customer Reviews (13)

For C programmers, Fortran programmers get a challenge
For the undergraduate or graduate student who programs in C, this book is a well-written and informative introduction to MPI programming. However, for the old-school Fortran programmer, the book offers little guidance. Typical students today will be writing code in C (or its derivatives), and so the choice of programming language is logical, but I have still spent a lot more time online looking up MPI Fortran code and syntax than using the book.

Overall, the text itself is solid and readable. A Fortran version of the text would be nice, but the online code snippets are good enough to get you started.

Great for MPI beginners
Pacheco's book is a strong, gently paced introduction to a very complex API. MPI, the message passing interface, is the most common coordination tool for parallel scientific computing. When a Blue Gene programmer has 1,000 or 100,000 processors all working on different parts of one calculation, there's a big problem in getting partial results from where they're computed to where they're needed. That's what MPI is for.

When the problem is so complicated, the solution is also complicated. Pacheco does a good job of breaking MPI down into digestible pieces, starting with the basic send and receive primitives that you'll use most often. He presents each new part of the API in terms of some problem to be solved, keeping a concrete and practical tone to this book. He gradually adds more pieces in terms of more practical exercises: broadcasts and reductions, scatter and gather, data structuring, communicators, and asynchronous IO.

Along the way, Pacheco introduces algorithms that even experienced uniprocessor programmers may not be familiar with, including bitonic sorting and Fox's algorithm for matrix multiplication. This isn't gratuitous intellectual showmanship. It's a pointed demonstration that, when communication barriers change the computation landscape, old paths to solutions may not be the best routes any more. After finishing with the MPI API itself, Pacheco presents debugging techniques and common kinds of support libraries, as well as basic techniques for analyzing the potential and actual acceleration possible for a given problem.

If you're serious about MPI, you'll need the official standard for understanding the fussy details of these complex APIs. That's a pretty brutal way for a beginner to get going, though. This introduces not only the basic concepts of MPI, but also the basics of how to think about highly parallel programming. And, as multi-threaded multi-core multi-processor systems become common, that's an increasing percentage of all programming.

//wiredweird

Your MPI on-ramp
I read this book over the past week, covering chapters 1 through 6, skimming 7-10, and reading 11 through the final chapter 16. Its basically applied MPI programming, done up very well and clearly, starting with architectural history & motivations and leading into a simple numerical integrator example program in chapter 4 (chapter 3 was the MPI `hello, world'). The coding used is C, and I wrote my own integrator after finishing chapter 4 to also explore floating point numbers in calculations, loop control, and to integrate arbitrary functions on arbitrary intervals with adjustable resolution. The integrator is developed more fully throughout the book wherein MPI performance issues of the original design are pointed out and polished off as additional MPI functions and techniques are introduced. Some of these techniques included tree-structured initialization & broadcasts, data communication optimizations (such as derived types, packing / unpacking, etc), and guidance as to when certain techniques would be more useful than others offered by MPI. Communications are further advanced later in the book where the important non-blocking forms and more advanced concepts are brought to light & illustrated. Empirical analysis of algorithmic performance occupies two full chapters and is very interesting, including a detailed look into Amdahl's law. Its an excellent example of why we should keeps our eyes open in research. Program design & troubleshooting are also covered, but I only skimmed those chapters. Several parallel algorithms and some parallel libraries are also treated well in the text. At only 362 pages, (minus appendices) this book is a quick read and a superb lab manual. If you are a software developer just now getting into MPI, this book will certainly accelerate you onto MPI with the confidence that you can do anything with it. Just give it a week of your time. Its the perfect self-study manual.
5-stars

Just what I needed
I was looking for a good introduction into MPI to parallelize some software I had written. Somehow, no online resources seemed to cover the topic well, so $30 seemed like a worthwhile investment, compared to my time. I got this book and the more recent one by Quinn (PP in C with MPI and OpenMP). This one's the hands-down winner. I basically scanned it in bed for three nights, and two weeks later my code is running like a charm. Just the right mix of reference and tutorial, very little distraction, and a pleasant read throughout.

Highly recommended.

Well written, easy for someone who is not an MPI guru... yet
The book is written very well and goes through how the MPI functions work and all their parameters in pretty fine detail.He even talks about the simpler things many books overlook.The only thing I wish was in this book, and this has nothing to do with the quality of the book, is some C++ reference or talk of the C++ MPI calls.This book is written with examples in C only (I think FORTRAN one may be available online), but the theory he teaches and the design of the programs will work for any language, of course.It would be nice to have a good reference chapter that lists the FORTRAN MPI functions and the C++ ones too though. ... Read more

Product Description

Beginning Object-Oriented Programming with Visual Basic .NET 2.0 is a comprehensive resource of correct coding procedures. Author Dan Clark takes you through all the stages of a programming project, including analysis, modeling, and development, all using object-oriented programming techniques and VB .NET.

Customer Reviews (6)

Highly Recommend this vb.net oop book
If you are not real OOP developer, you have to read this book.
The author explains many oop knowledge clearly and easily to understand.
This is the only book that really combine oop theory and ve.net. The important thing is you can understand it and you can do it.
I try to contact the aurhor to know the next step book what I need to read.

A gem!
I thought the first 4 chapters were boring, but in fact the idea was to build your skill before you code the application! This book was written in a way that readers should already be familiar with OOP terminologies because it does not go into detailed explanation like those for dummies books do.Instead, it shows you how to analyze a problem, draw the diagrams and design the application! This is so far the best book i've read about object-oriented programming using VB, toppling Deb Kurata's or Alistaire Mcmonnies' books on my list. This book will teach you how to do UML/USE CASE so you can design a robust application. This is not a beginner's book on object oriented VB. I've had some knowledge in Java object programming and I know a little of object programming, but reading this book the first time has confused me as the author seemed to have tried to squeeze the discussions in short chapters and programming codes are not explained well, delving right into OOP design and techniques. As the author mentioned in the book, he doesn't know the skill level of a 'beginner', so he added some short intro to programming at the back of the book (Appendix A), so I believe the audience of this book are those 'beginners' to OOP but not to programming. I applaud Dan Clark for the way he laid out the teaching concept of this book, and how I wish he would follow this up with an advanced book with lots of case studies and applications starting from analysis to coding again. Highly recommended!

Book in very good condition
This book is in very good condition.Shipping very fast.Overall I'm very satisfied with my purchase.

I thought I got the shaft, but then discovered the gold.
I performed some programming in Visual Basic 6 a few years ago and then my job was changed so that I was maintaining a Unix program for a few years, which entailed putting fires out each day and very little programming of any type.A few months ago I was fortunate enough to get transferred to a great job programming web sites and some Windows applications. I've been able to write some fairly complex programs, but I knew I was missing some large piece of the puzzle. I'm really a novice programmer.I wasn't creating classes and I wasn't doing a lot of things that were efficient.If my programs needed to do more or scale, they were very difficult to adjust.During these months I've purchased a lot of books, and they had good stuff in them, but I still wasn't able to put things together.I would see things like "WithEvents" and ask what was that for.I had to do some threading and succeeded, but only by trial and error and I didn't understand the "why" of why it worked. For that matter, there was a lot that I didn't understand the "why" about.

I then thought that, even though I was using objects, that I didn't really understand object-orientated programming enough.I looked on some User Group sites and saw this book listed as a good one.

I held high hopes for this book. It's my first book from Apress.I started reading the first 4 chapters, which were on how to design and plan an OOP program.I'm convinced his information is important but ugh!It was horribly boring!I was mostly through the 2nd chapter when I thought I'd committ suicide .I had to quit reading chapters 2-4 and tell myself I'll get back to that later.Yes, it's that boring.It's worse than hearing your girlfriend talk for hours about makeup and dresses!So I skipped to Chapter 5 which gave basic instructions on using Visual Studio.I thought, "Why put this beginner's crap in this book".If you need to know the basics of VS, then get a beginner's book on VS. It shouldn't have been here.
By this time I'm thinking I bought a book of garbage.But I went on to Chapter 6, and I'm glad I did.It finally got to the point and started talking about OOP and classes, constructors, overloading - and I was getting some of the elusive "why" explained!Chapter 7 got into inheritance, derived classes, overriding and overloading, etc with more of the "why".Chapter 8 got into the stuff like "WithEvents" and delegates, and how delegates work with threading.You will need to use threading and you will see "why".In geekspeak, threading is cool!Chapter 9 shows how to work with Collections (arrays, dictionaries, etc).This chapter didn't explain much "why" but when I need Collections there is enough to be able to implement them. Chapter 10 starts explaining some "why" regarding databases, such as connected versus disconnected data access.The examples use SQL Server.Chapter 11 looks at forms in a different light from other books, looking at them as objects instead of just sticking controls on them, and works with using databases more.

Now I feel better about going back to the first 4 boring chapters as I will now have something to build with.

To a complete beginner, I would say to first get a basic VB.NET beginner's book and get familair with VB and Visual Studio. If this is your very first book you will be very lost.The book is made for a novice.

This book is one of the most important I have read.I am making progress very quickly over the last week or two, while previously I sputtered for several months.I've tried to convey how I felt, and if you feel similar, you must get this book.

Not exactly Like the title says
I have to admit, has some interesting stuff and information on how to make the theory of Classes to Programs, but I can not agree that is novice to professional, in my opinion I would say just novice.

Leaves many un-answered questions.

But can work as a reference. ... Read more

Product Description
A Newnes Kindle Book. ... Read more

Customer Reviews (7)

Actually teaches embedded C!
Conclusion:
This was the book that "got me over the hump" and I am now comfortably programming PIC microcontrollers in C using the CCS compiler.Overall, I am very happy with this purchase and think that the price is very reasonable for the knowledge that you gain from this text.

Comments:
If you know about embedded systems, you know that they are the most basic elements of circuitry.All they are is a chip and you have to figure out how to make it "Go" and do something useful.Just getting it to turn on takes an organized act of programming and hardware together.By contrast, most books on learning C programming start with the almost famous printf ("Hello World"); program that requires not only that the processor be running, but that it have some kind of output device (Monitor, printer, etc.) attached to it and be working.In other words, this is practically impossible to accomplish as you have to have a completely functional system and a high level of proficiency in programming before you can even start to learn how to program.I own a sizable stack of books on learning C and they all subscribe to this same backwards technique and have all proved useless toward actually learning C on embedded systems.Martin Bates book is the first one that I have read that starts with turning the processor on and takes you through turning an LED on which is a realistic example of a first C program with a microcontroller.You already have a half-dozen or so projects under your belt before you see a printf statement, which is the ONLY way to do it in an embedded world.

I don't really have all that much negative to say about this book.It does use the Proteus simulator for most of the projects in the beginning, which I elected not to use and to do it all in actual hardware.I am not interested in trying to learn two tools at the same time, so this caused me to have to "modify" the programs slightly to run on my hardware.This was ultimately a good thing and helped me learn, but it is notable.The middle section of the book uses the actual hardware from the Microchip PICDEM Mechatronics board that has motors and stuff on it, which makes that part kind of fun to do.

Another thing that I would like to address is the other reviews talking about the membership to the website and all of that.This is not a required part of the curriculum and is barely mentioned.I never looked for it as I didn't need it.

Need to focus on programing
I purchased and read the book and was a bit disappointed in the author. I felt he talked more about the developed tools then programming. Not all users own CCS software to write C codes and I felt the author should have cover more on the programming of how to set up header files ect. I use Hi-tech software for writing my C codes and not all of the codes in his book worked with Hi-tech software. I also went to the web pages that the author mentions in his book and I could not get on the web page. I would rate this book very low unless you have the CCS software to work with this book. This book made me much wiser on the purchase of my next book.

A manual not a textbook
I consider this to be the worst kind of textbook, unsure of what might be a reader's previous experience, at one and the same time assuming certain information while supplying information that would likely be learnt at the same time as the assumed information. It is vague in its starting position, theoretically weak in its content, and constituted mainly from material that is available in any decent C-language book like K&R, the manual for a compiler targeted at the processor, and the data sheet from the microcontroller manufacturer. Books by the likes of Wilmshurst or Wolf are much better, and better value.

False advertisement
The book itself is fine and I got it, but I specifically ordered this book because it said that it would be here that friday after I ordered it. Well it took about a week longer than it said. I missed my homework assignment because of this.

Not as advertised - beware
The printed content of this book seems reasonable for the price if a bit lower level than expected.However, the book claims to provide membership to a web site that would provide additional specific tools for PIC use and applications.This access is not available.The tools are not available.Attempts to contact the author and the publisher to resolve this issue went unanswered.Amazon customer support could not resolve this issue either. ... Read more

Product Description

Parallel programming has been revolutionised in .NET 4 providing, for the first time, a standardised and simplified method for creating robust, scalable and reliable multi-threaded applications. The Parallel Programming features of .NET 4 allow the programmer to create applications that harness the power of multi-core and multi-processor machines. Simpler to use and more powerful than “classic” .NET threads, parallel programming allows the developer to remain focused on the work an application needs to perform.

In Pro .NET 4 Parallel Programming in C#, Adam Freeman presents expert advice that guides you through the process of creating concurrent C# applications from the ground up. You’ll be introduced to .NET’s parallel programming features, both old and new, discover the key functionality that has been introduced in .NET 4, and learn how you can take advantage of the power of multi-core and multi-processor machines with ease.

Pro .NET 4 Parallel Programming in C# is a reliable companion that will remain with you as you explore the parallel programming universe, elegantly and comprehensively explaining all aspects of parallel programming, guiding you around potential pitfalls and providing clear-cut solutions to the common problems that you will encounter.

What you’ll learn

• Develop scalable and robust parallel applications in C#.
• Design, test and use parallel algorithms and data structures.
• Understand and implement common parallel design patterns.
• Avoid common anti-patterns and problems.
• Use Visual Studio to verify and debug parallel applications.

Who this book is for

This book is for .NET developers encountering parallel or multi-threaded programming for the first time. No prior knowledge of multi-threaded programming is required, but the reader should be familiar with basic programming in C# using Visual Studio.

Customer Reviews (3)

Good Walkthrough, Great Book
I thank author about the walkthrough especially for beginners. Great examples. Even we have code downloaded, it would be better to give Program Output for all the examples. Some of them are missing output. Whenever we read it in kindel, we dont have computer program opened. So, felt, if we had Program Output, it will help us.
Finally, really great book.

Good Book
Great book, reommended even if you are a newbie on parallel programming. The examples are quite illustrative, close to real world applications. The only reason for rating it as 4 stars it's because the print/paper quality of Apress books it's not as good as it was a few years ago.

Pleased
As a novice C# programmer with no experience in Parallel/threaded programming I just spent a week with this book. First let me say all the downloaded code examples worked on VS2010 without any changes.All the code was well documented with very clear examples of what was being discussed. He covers just about all the Calls in the TLP task programming extensions with examples. I found that to be very valuable.I would guess a more experienced programmer could find that same information in the Microsoft Documentation, but withouta starting point I found it very helpful. It was laid out well and as new " problems" arose the answer was just around the corner.I was very pleased overall as I felt I was on a guided journey into new territory. ... Read more

Product Description

• Unified Parallel C (UPC) is an extension of the widely used language C, which was designed for use with massively parallel computers
• This is the first book devoted to UPC and the authors are among the developers of UPC
• Covering background material on parallel architectures and algorithms, this book is an invaluable reference for UPC users and applications developers
• Includes UPC programming case studies

Customer Reviews (1)

interesting superset of C, but why did it not extend C++?
Think of this book as the equivalent of Kernighan and Ritchie's epochal book on C programming. It aspires to the same role, with respect to Unified Parallel C. Clearly, for ease of understanding the book, you should have already programmed in C. Which is a pretty safe assumption, as C has been and still is one of the most common languages.

UPC is a superset of C, so all existing C programs can run under UPC recompilation. The crucial difference is that UPC permits a set of threads, where these are fixed at runtime. A thread can have private variables, that other threads cannot access. Or it can have shared variables, so that threads can easily communicate. The latter is a nice aspect. Perhaps you have dealt with interprocess communications? Under unix, there are all sorts of complicated methods to do so. Locks, semaphores etc. By contrast, the text shows that accessing shared variables in UPC is quite easy.

Perhaps the biggest drawback about UPC is that it is not object oriented. The scaling difficulties with C code are well known, and proved crucial in driving the use of C++ and Java, and C# for that matter. If only the designers had chosen to have UPC extend C++, instead of C. But perhaps there were performance drawbacks in doing so, or that the resultant UPC compiler would have been too hard to build? The book avoids this discussion. ... Read more

Product Description
Haskell is one of the leading languages for teaching functional programming, enabling students to write simpler and cleaner code, and to learn how to structure and reason about programs. This introduction is ideal for beginners: it requires no previous programming experience and all concepts are explained from first principles via carefully chosen examples. Each chapter includes exercises that range from the straightforward to extended projects, plus suggestions for further reading on more advanced topics. The author is a leading Haskell researcher and instructor, well-known for his teaching skills. The presentation is clear and simple, and benefits from having been refined and class-tested over several years. The result is a text that can be used with courses, or for self-learning. Features include freely accessible Powerpoint slides for each chapter, solutions to exercises and examination questions (with solutions) available to instructors, and a downloadable code that's fully compliant with the latest Haskell release. ... Read more

Customer Reviews (18)

Who's the audience?
I'm a mathematician who decided Haskell would be a good language in which to perform my latest computing task, so I looked around for learning materials.After going through some web tutorials and starting into _Real World Haskell_, I decided that maybe I should try something more basic and systematic, so I read Hutton's book.I'm glad I did, and I think I understand Haskell much better now than I did before.

The form factor of this book is really odd, essentially that of a thick magazine, like _Wired_.It has huge outer margins, with the text compressed into the middle in tiny-looking 9-point type.Thankfully, the printing is crisp, so the text is fairly readable.Choosing to set the code samples in a proportional font seems like a curious choice, especially for Haskell, where spacing matters.For a computing book, the writing is very elegant, although the organization is somewhat less systematic than I was expecting.

The most questionable aspect of this book is its audience.Ostensibly, it is written for a first university course for students with "[n]o previous programming experience", but I'm not sure how good of a fit it would be, especially for a typical U.S. student.Concepts like pointers, parsers, stacks, and compilers seem to be mentioned with the idea that readers would already know what those are.The examples in the book are largely drawn from Hutton's professional publications in functional programming.To me, these were interesting, but it's not clear how much new students would appreciate them.Contrast that with the fact that mathematical induction is discussed at length as if the reader might be unaware of it, and on page 147 the reader is referred back to a previous derivation for justification of the FOIL formula from basic algebra!The selection of exercises seemed kind of sparse for a textbook.

_Programming in Haskell_ is a quick read, and (if you can afford it) is probably a good stepping stone on the way to being a good Haskell programmer.

Good book
If you're looking for a book to walk you through haskell and provide slides to students and instructors online, this book is great.

It assumes no previous programming knowledge and is very thorough.

Good introduction to Haskell
Programming in Haskell by Graham Hutton is a great introduction to Haskell. Hutton gets into Haskell without complicating the subject. The book is just 184 pages. The book combined with Erik Meijer's lectures will make functional programming clearer for most of the folks out there.

Decent Introduction to Haskell
This text certainly won't bring you up to the level of Real World Haskell. However, I can imagine that for a total beginner this would probably serve as a good primer to build confidence before tackling RWH. The book itself is very clear and elegant, if somewhat slow in pace. Bottom line: if Real World Haskell is somehow intimidating for you, read this first.

Among the most elegant CS books I've read
"Programming in Haskell" is among the most elegant computer language books I've read, and it will go on my shelf next to The Little Schemer and Godel, Escher, Bach.

I'm coming from the typical experienced C/C++/Java/Python background, with some past toying with Scheme.

The text presented an enlightening and well explained new concept in typed functional programming on nearly every page, with Haskell used as an excellent medium.

My only regret is that now I realize just how impoverished C/C++ and my other day-to-day languages are - although the functional approach is infecting my style even there. ... Read more

Product Description
Servlets are an exciting and important technology that ties Java to the Web, allowing programmers to write Java programs that create dynamic web content.Java Servlet Programming covers everything Java developers need to know to write effective servlets. It explains the servlet lifecycle, showing how to use servlets to maintain state information effortlessly. It also describes how to serve dynamic web content, including both HTML pages and multimedia data, and explores more advanced topics like integrated session tracking, efficient database connectivity using JDBC, applet-servlet communicaton, interservlet communication, and internationalization. Readers can use the book's numerous real-world examples as the basis for their own servlets.The second edition has been completely updated to cover the new features of Version 2.2 of the Java Servlet API. It introduces chapters on servlet security and advanced communication, and also introduces several popular tools for easier integration of servlet technology with dynamic web pages. These tools include JavaServer Pages (JSP), Tea, XMLC, and the Element Construction Set.In addition to complete coverage of 2.2 specification, Java Servlet programming, 2nd Edition, also contains coverage of the new 2.3 final draft specification.Amazon.com Review
Aimed at Web developers with some previous Java experience, Java Servlet Programming, Second Edition, offers a solid introduction to the world of Java development with Servlets and related technologies. Thoroughly revised and newly updated with over a half-dozen new chapters, this title brings an already useful text up to speed with some leading-edge material. It excels particularly in explaining how to program dynamic Web content using Java Servlets, with a fine introduction to all the APIs, programming techniques, and tips you will need to be successful with this standard.

Besides a useful guide to APIs, the book looks at a variety of techniques for saving session state, as well as showing how Servlets can work together to power Web sites. You will learn performance tips and ways to get Servlets to work together (like forwarding and redirection), plus the basics of database programming with JDBC, to build content with "live" data. A later chapter examines what's next for Servlets with the emerging Servlet 2.3 API standard. Importantly, the authors go over deploying and configuring Web applications by editing XML files, a must-have for successfully running Servlets in real applications.

Since the first edition of this title, the choices for Java Web developers have grown much richer. Many of the new chapters in this edition look at options beyond Servlets. Short sections on application frameworks such as Tea, WebMacro, the Element Construction Set (ECS), XMLC, and JavaServer Pages (JSP) let you explore what's out there for Java developers today with a survey of some current tools that can speed up creating new Web applications.

The text closes with reference sections on Servlet APIs (and other material) that will be useful for any working developer. Although Servlets are not the only game in town, they are still important tools for successful Web development. This updated edition shows you just how to do it with plenty of basic and advanced tips for taking full advantage of this powerful Java standard. --Richard Dragan

Topics covered:

• Overview and history of Java Servlets
• Fundamentals of HTTP
• Web applications (including deployment and configuration using XML files)
• The Servlet lifecycle (initializing, processing requests, cleanup, and caching)
• Multimedia content (images and compressed content)
• WAP and WML for wireless content
• Servlet session tracking techniques (hidden form fields, cookies, and URL rewriting)
• Security issues with Servlets (including certificates and SSL)
• Tutorial for JDBC and Java database programming
• Using applets and Servlets together
• Servlet collaboration
• Quick introduction to Java 2 Enterprise Edition (J2EE)
• Internationalization issues
• Survey of third-party Servlet application frameworks and tools: Tea, WebMacro, the Element Contruction Set (ECS), XMLC, and JavaServer Pages (JSP)
• Miscellaneous tips for Servlets (including sending e-mail and using regular expressions)
• Description of the new Servlet 2.3 API spec
• Servlet API quick reference

Customer Reviews (156)

Disapointing, not for beginers nor experts
I do not recommend this book. It does not keep the usual "level" of the O'Reilly ones.

The prose is a bit boring and there is not much insight on the subject (nor covers a beginner view on the subject).

Excellent book on Servlets and Java
If you do not understand servlets and program in Java this book is for you.I found it very easy to read and comprehend right off the bat.The examples are excellent and you will get off writing servlets very quickly.It is somewhat shallow in complex examples but then again how complex are servlets.Some best practices and commercial examples could have helped a lot.

Excellent in-depth book
I completely agree with the 5-star positive reviews listed here. I saw a couple of new ones that were not so positive, so I wanted to voice my opinion.

This book is very well written - well structured, with in depth explanations, humor, good code examples. It can be used both as a tutorial and as a reference.

Even though it may be showing its age now in a couple of places (e.g. Tapestry is not mentioned, uses JDK 1.0 and 1.1 for the examples), it is still very good. It paints a complete picture, so one ends up with understanding of the principles and architecture - which is what matters - for the updated APIs there is always JavaDOC.

I don't know how suitable it is for beginners, but for an experienced programmer it is a thoroughly enjoyable read - once I started it I couldn't stop until I finished (I didn't actually type the examples - that isn't necessary for understanding the material) .

Nicely Done
This book's examples in later chapters may be a bit much for the beginner, but it does a good job of covering thing very well. Good coverage of various protocols, etc.

ok book, not the best tutorial
I found this book to be semi helpful. It would have been nice if it was more tutorial like.The examples also were not the most straightforward.The book does cover alot though. ... Read more

Product Description
This book is the first comprehensive presentation of the principles and tools available for programming multiprocessor machines. It is of immediate use to programmers working with the new architectures. For example, the next generation of computer game consoles will all be multiprocessor-based, and the game industry is currently struggling to understand how to address the programming challenges presented by these machines.This change in the industry is so fundamental that it is certain to require a significant response by universities, and courses on multicore programming will become a staple of computer science curriculums.The authors are well known and respected in this community and both teach and conduct research in this area. Prof. Maurice Herlihy is on the faculty of Brown University. He is the recipient of the 2003 Dijkstra Prize in distributed computing. Prof. Nir Shavit is on the faculty of Tel-Aviv University and a member of the technical staff at Sun Microsystems Laboratories. In 2004 they shared the Gödel Prize, the highest award in theoretical computer science.* THE book on multicore programming, the new paradigm of computer science* Written by the world's most revered experts in multiprocessor programming and performance* Includes examples, models, exercises, PowerPoint slides, and sample Java programs ... Read more

Customer Reviews (11)

the code is misleading sometimes, so is the text
The contents of this book and the range of topics exposed are just brilliant.
But as for the correctness, it wants much more.

It has been already said in another review about bugs in read-write locks implementations, now I may add that authors seem not to understand what the semaphore is (I'm kidding), presenting it as a generalization of mutex, i.e. JUST as an object enabling entrance to a "critical section" for N threads. They even say about N as about a "capacity of semaphore" - its inherent property, and preserve that "capacity" as a constant member of their semaphore class - the correct but rather misleading implementation.

They use a reenterant (recursive) lock to implement read-write locks. Why? I could not understand, nor they explain. A non-recursive one would be pretty sufficient. And I extremely "liked" an idea of waiting for condvar under a recursive lock.

Then they say a thing like "A memory barrier instruction ... flushes write buffers [of processors - M.P.] , ensuring that all writes issued before the barrier become visible to the processor that issues the barrier".

The bottom line I may say is: if you know a better book, buy it. If not, and if you are tired of getting through "just another book explaining critical sections and stuff like that" and have some passion for reading half-practical, half-academic texts - you may want to read this book and appreciate it greatly. At least as an introduction to not so trivial subjects.

And... if you are a junior in this subject - you might be in danger of adopting some wrong concepts and practices. Beware.

At the Border of Theory and Practice
What this book is not:
- A programmer's cookbook
- A programming manual
- A math text

This is an engineering theory textbook: enough theory to teach you how to reason about practical problems on the problems' own terms.If it were easy, such books would be unnecessary.Learning to reason about these problems is hard and the books are hard.This book is no exception.That said, it is generally very clear, but it is not light reading or easy study.It demands serious study time.Given the increasing importance of concurrency to real-world performance (and the economics of computing) the investment of time seems likely to be profitable.

The book progresses from simple (but still difficult) foundation principles to a variety of established techniques.It is not concerned with other issues of software design and construction but it covers its own purview thoroughly.

The exercises are non-trivial and sometimes geniunely hard.Some call for programming, some for thinking.They indicate that the authors have a deep grasp not only of their subject matter but of how to teach it.The examples are in Java.(A note on doing the exercises: due to the inherent limitations of threading on single-processor/single-core/single-thread machines, errors in code may not show up on such machines; if you don't have true multi-thread hardware, beware.)

Great class, great book
I took a class with Professor Herlihy at Brown in which he used perhaps an early version of this text.It was a great class and a great textbook, likely one of the best, most understandable texts I've encountered in the world of advanced computer science.The chapters are relatively short and to the point, each requiring no more the 30 - 45 minutes of reading.It's very well paced and you never feel that familiar information overload so common in computer science texts. This is quite a feat for an advanced topic in computer science.It's also quite accessible, it seems someone with only cursory understanding of basic computer science could grasp much of what is conveyed, while at the same time it never feels "dumbed down" for the laymen. Highly recommended!

Not recommended for enterprise architects
If you're working in a large enterprise, the major trends at the moment are SOA and SaaS - and this book does not deal with them in the context of multicore.The books is also too academic and there's too much theory and not enough practical advice for enterprise architects.

Soon to be the classic text on multiprocessor programming
The Art of Multiprocessor Programming is an outstanding text that will soon become a classic. I give a chapter by chapter review of it below.

Practitioners that are already well versed in parallel programming can jump directly to Chapter 7, however, I would suggest at least skimming Chapters 2, 3 and 4. Even those programmers who understand shared memory and locking may be shocked at how relaxed memory models or compiler optimizations can reorder operations causing innocent looking code to break.

----------------------------------------

Chapter 1 - Introduction

Why is this book called "The Art of Multiprocessor Programming" and not "The Art of Parallel Programming?" It is not by accident. There is a directed effort to explain parallel programming concepts as they relate to multi-core (or many-core) architectures. In particular, shared-memory multiprocessors have specific implementation details, such as cache coherence policies, that directly affect parallel software run on such architectures. The introduction gives a brief overview of the direction of the text: principles and practice.

----------------------------------------

Part 1 - Principles

Chapter 2 - Mutual Exclusion

Mutual exclusion is a key concept to multi-threaded programming, and this chapter is rightly placed at the beginning of the text. This chapter presents some of the foundational concepts in parallel computing, such as, understanding time related to operation interleavings, pessimistic critical sections, forward progress, deadlocks and fairness. In addition, some of the classic algorithms are presented here, such as Lamport's Ticket Locking and Peterson's 2-Threaded Lock.

Chapter 3 - Concurrent Objects

This chapter starts off simple, but gets complex fast. While experts will understand and acknowledge the importance of this chapter, less experienced programmers will find it very challenging to understand and may be turned off: don't give up!

My suggestion to non-experts is to focus on understanding two concepts of this chapter: hardware sequential consistency (3.4) and software linearizibility (3.5). Once you understand both concepts, skim all other sections except section 3.8.

Java programmers may want to pay special attention to the Java Memory Model section (3.8) and ill-formed unsynchronized code. General programmers will also be interested in this section as it is important to understand how the hardware's memory consistency model, the programming language's memory model and the compiler's operation reordering optimizations may interfere with what "looks like" correct code.

Do not be discouraged by the difficult of this chapter. It is one of the most difficult chapter in the text. Get through it and keep reading.

Chapter 4 - Foundations of Shared Memory

This chapter concentrates on understanding shared memory, the cornerstone of all multi-threaded applications. It explains how to implement shared memory that behaves "correctly" without using mutual exclusion. The different types of memory that are discussed are single-reader single-writer (SRSW), multiple-reader single-writer (MRSW) and multiple-reader multiple-writer (MRMW). This is an important chapter for non-experts to think about, as it explains how operation interleavings are not as discrete as we pretend they are and how shared memory should behave in all possible cases.

Chapter 5 - The Relative Power of Primitive Synchronization Operations

This chapter explains the varying strength of different wait-free synchronization primitives. Consensus numbers will undoubtedly confuse novice parallel programmers. In short, the higher the consensus number the better. A high consensus number, say N, for a synchronization primitive means that synchronization primitive can "correctly" solve the consensus problem for N concurrently executing threads. For example, critical sections have an infinite consensus number (e.g. support an infinite number of concurrent threads). Atomic registers have a consensus number of 1, they support only 1 thread's execution that is guaranteed to consistently and validly solve the consensus problem.

The most important point of this chapter (in my opinion) is that compare-and-swap (CAS), or compare-and-set, has an infinite consensus number (section 5.8). This is why modern instruction set architectures (ISAs) all provide CAS: it is critical to supporting an unlimited number of concurrently executing threads. Realizing the importance of CAS is vital for advanced parallel programmers who want to implement nonblocking algorithms.

Chapter 6 - Universality of Consensus

This chapter explains how to build universal consensus for your own concurrent objects. While it will be an interesting chapter for experts, novices may want to skip it.

----------------------------------------

Part II - Practice

Chapter 7 - Spinlocks and Contention

This chapter explains the important differences between different types of locking. It explains how to implement locks using assembly level operations (test-and-set and test-and-test-and-set), how to reduce bus contention using backoff, how to reduce cache pressure by having threads spin on their local cache memory and how to manage an unknown number of threads using locks.

After reading this chapter, most readers should have an appreciation for the hardware complexity of implementing something as simple as a lock. Some programmers may argue that they should not need to know how hardware behaves. While I would like to agree, the unfortunate state of multi-core programming currently requires a basic understanding of memory consistency models and cache behaviors. Herlihy and Shavit note this and make an effort to address it in a "just what you need to know" fashion, as done in this chapter.

Chapter 8 - Monitors and Blocking Synchronization

This chapter explains monitors, conditions, the differences between readers and writers, and reentrant locks. Java programmers will be especially interested in understanding monitors, while all OO programmers should have an appreciation of synchronizing an entire class. Moreover, the section on reentrant locks is simple but important to preventing deadlocks.

----------------------------------------

Unofficially, Chapters 9 - 11 focus on achieving parallelism in algorithms that have sequential bottlenecks and are therefore inherently sequential.

----------------------------------------

Chapter 9 - Linked Lists: The Role of Locking

The chapter explains how to implement ordered linked lists (e.g., IntSets or just sets) in a variety of different ways. The chapter starts out with the most basic implementation and then begins to increase performance by relaxing the strictness of the required thread synchronization.

Chapter 10 - Concurrent Queues and the ABA Problem

The chapter explains how to implement pools, a collection of unordered or ordered items. The chapter then explains the ways to implement pools as different types of queues, containers with first-in-first-out behavior. The chapter also explains a classic parallel problem known as ABA, where thread1 observes x == A, thread2 does x=B and then x=A and thread1 then observes x == A. The ABA problem is a subtle, but important problem.

Chapter 11 - Concurrent Stacks and Elimination

This chapter starts where the last chapter left off; it explains how to implement concurrent stacks, containers with first-in-last-out behavior. The chapter also explains a neat cancellation problem called elimination. Elimination is useful for avoiding overflows, underflows and other types of bounded problems.

Chapter 12 - Counting, Sorting and Distributed Coordination

This chapter explains how to take problems that seem to be inherently sequential and make them parallel. The chapter also explains both combining and diffracting trees, both of which are very interesting ways to make sequential problems parallel. This chapter is one of the more complex chapters of the text. Some readers may want to skim it.

----------------------------------------

Unofficially, Chapters 13 - 15 focus on achieving parallelism in algorithms that are inherently parallel. Readers will enjoy seeing how easy it is to extract parallelism in these naturally parallel algorithms.

----------------------------------------

Chapter 13 - Concurrent Hashing and Natural Parallelism

This chapter explains how to build parallel hash tables, with both open and closed addressing. First, the authors explain how to implement hash tables using coarse-grained locks, then with fine-grained locks, then with no locks at all. The chapter also explains how to deal with open-addressed hash tables which are particularly challenging.

Chapter 14 - Skiplists and Balanced Search

Most non-experts that make it this far in the text will be greatly rewarded by this chapter. Chapter 14 explains skiplists, an intriguing way to implement a container that has logarithmic search time and that is inherently parallel. Unlike red-black trees or balanced binary trees that yield logarithmic search time complexity, skiplists do not need to be rebalanced. Skiplists do not need to be rebalanced due to their unique algorithmic layering, making them inherently parallel. As such, skiplists have a notable benefit over their inherently sequential logarithmic search time counterparts.

This is a critically important chapter for practitioners hoping to exploit high parallelism while retaining logarithmic search time.

Chapter 15 - Priority Queues

This chapter explains how to implement priority queues, containers that are queues where each element has an identifiable level of importance. The authors demonstrate how to build priority queues with arrays, trees, heaps and skiplists.

Chapter 16 - Futures, Schedules and Work Distribution

This chapter presents some important aspects in understanding parallelism. In particular, the authors explain how to keep threads busy with work without causing the threads to become busy with "looking for work". The chapter also explains important ideas about the overhead of threads, stealing work, and sharing work. This chapter may cause some confusion to non-experts, but readers should try to understand at least the basic principles conveyed here as they are important to most general parallel programming problems.

Chapter 17 - Barriers

This chapter explains how to use barriers, a synchronization primitive that ensures threads move together through "gates" or "phases". Barriers are important in preventing threads from getting to far ahead or too far behind one another.

Chapter 18 - Transactional Memory

This chapter briefly describes a new parallel programming concept called transactional memory (TM). TM uses optimistic concurrency and greatly simplifies parallel programming. Herlihy and Shavit are responsible for HTM and STM, respectively.

The following ideas are touched on: HTM + cache coherence, composition, contention managers and transactional serialization. TM is currently receiving a lot of research attention and many researchers believe TM will soon become the new way to do parallel programming. Because of this, readers should pay particular attention to this chapter.

... Read more

Product Description

• This comprehensive introduction to SQL Server begins with an overview of database design basics and the SQL query language along with an in-depth look at SQL Server itself
• Progresses on to a clear explanation of how to implement fundamental concepts with the new 2008 version of SQL Server
• Discusses creating and changing tables, managing keys, writing scripts, working with stored procedures, programming with XML, using SQL Server Reporting and Integration Services, and more
• Features updated and new material, including new examples using Microsoft's AdventureWorks sample database

Customer Reviews (5)

Big enough to stop a train, but filled with good bits...
No one will remember tech books as great literature. They're a vast linguistic junk yard, yes, but at least one with a purpose. Although most teachers would flinch until their undies imploded at the thought, one can learn something from even a poorly written book. And look no further for bad writing than tech books. Their rush to market eagerness and probable demographic presumptions likely explain their often appalling syntax and spelling. Of course no one wants to read sloppy prose in any genre, but who really reads tech books for their literary qualities? If such a person exists, a slobbering impresario with a reality show contract likely awaits. The ultimate test for tech books remains utility. Can one read a given book and then produce something decent? If yes, then something of value exists.

Wrox books possess enough bulk to function as doorstops or bridge struts, definitely. And often the author/programmers' grinning or deadpan faces glaring in not extremely appealing black, white and red contrast don't inspire aesthetic spasms. Nonetheless, what they lack in artistic merits they often make up for in technical knowledge. "Beginning Microsoft SQL Server 2008 Programming" stands as one Wrox book that, for the most part, delivers. Anyone who has found themselves thrown head first into database programming can easily osmose the basics from this tome. It takes a while to read, but the investment pays off in depth of knowledge. Working with databases on any professional level would prove difficult without mastering this book's first twelve chapters. Go ahead and try, but have your resume ready. And though some software developers, particularly of the .NET variety, may now rest content with LINQ, knowledge of SQL and database technology would only enhance their skill sets. This book provides just the right background for such people.

Though the book contains some rough spots, coverage of the main points of T-SQL remains more than adequate. From SELECT, JOIN, CREATE, ALTER, CONSTRAINT, to normalization, views, stored procedures, user defined functions and triggers, this book will help anyone whose boss suddenly orders them in front of SQL Management Studio. Though more coverage of cursors would help beginners who find themselves faced with these monstrosities. And the trigger chapter leaves those murky and dangerous objects, which lurk like methane bubbles beneath cracking ice, still mysterious. The book's final sections provide previews of the "SQL Stack," which includes Integration Services (SSIS), Reporting Services (SSRS) and a dabbling of Database Administration. These provide only a meager tease. Larger books than this one exist on SSIS alone. Once again, this book requires a time investment. An installation of the SQL Server 2008 client also helps (other books cover the server side). But, like any investment, it can pay off when study integrates with practice.

Review Text
This book was purchased in hard copy even though I have access to an Ecopy. It is the exact as we aqre using in class and just as advertised. No torn pages, no markings. I would definitely buy from this seller again.

Proof that Wrox does NOT have editors
Computer books are thrown together so carelessly these days.Look at the table of contents for Chapter 8.Almost all of its topics are to be found on page 260... and page 260 barely has any text!I'm astonished at how pitiful the quality control is on this junk!

SQL Server easy
Although the book is good, the author uses everyday language frequently, which hinders the understanding of readers from countries where English is not spoken as a native language. Also, it ignores the process and the prerequisites for installation.

A great beginner book
This is a great beginner's book on T-SQL programming. I like the Author's writing style and comprehensive coverage of all the topics including Reporting, XML, Integration Services, UDFs, and even some Administration tasks. The stored procedure chapter could have been made into two chapters. Also, I was surprised why more examples were not given for the Try/Catch error. Similarly, there was not much to go with the SSIS. Looks like most of the typos in the book were removed since the 2005 publication. Overall, a great book to get one started.
... Read more

Product Description
Turing, a well-structured and straightforward programming language that supports object-oriented programming, is introduced by this book. Each chapter ends with a collection of exercises to develop confidence and familiarity with Turing and with general principles of programming. The disk contains OOT for Windows--the object-oriented version of the language designed to run in Windows. ... Read more

Product Description
Programming Language Pragmatics is the most comprehensive programming language textbook available today. Taking the perspective that language design and language implementation are tightly interconnected, and that neither can be fully understood in isolation, this critically acclaimed and bestselling book has been thoroughly updated to cover the most recent developments in programming language design. With a new chapter on run-time program management and expanded coverage of concurrency, this new edition provides both students and professionals alike with a solid understanding of the most important issues driving software development today.

• Classic programming foundations text now updated to familiarize students with the languages they are most likely to encounter in the workforce, including including Java 7, C++0X, C# 3.0, F#, Fortran 2008, Ada 2005, Scheme R6RS, and Perl 6.


• New and expanded coverage of concurrency and run-time systems ensures students and professionals understand the most important advances driving software today.


• Includes over 800 numbered examples to help the reader quickly cross-reference and access content.

Topics covered: A survey of today's programming languages, compilation vs. interpretation, the compilation process, regular expression and context-free grammars, scanners and parsers, names, scopes and bindings, scope rules, overloading, semantic analysis, introduction to computer architecture, representing data, instruction sets, 680x0 and MIPs architectures, control flow and expression evaluation, iteration and recursion, data types, type checking, records, arrays, strings, sets, pointers, lists, file I/O, subroutines, calling sequences and parameter passing, exception handling, coroutines, compile back-end processing, code generation, linking, object-oriented programming basics, encapsulation and inheritance, late binding, multiple inheritance, functional and logical languages, Scheme and Prolog, programming with concurrency, shared memory and message passing, and code optimization techniques. ... Read more

Customer Reviews (25)

Comprehensive Programming Language reference

Well written and organized text with in depth history and explanation for Programming Language Pragmatics.

good book
I am currently using this book for a class in programming semantics.The book is clear in its explanations and diagrams.I also like the additional content on the CD... this is the first book CD that I have used more than once!In my opinion great book.

a fine text
I have found this book to be useful as a means of becoming familiar with the considerations that one needs to keep in mind when designing programming languages. I found that I needed a supplementary book on theory of computation, as those topics are relevant, but not covered in this book. On the whole, it's a well-written book, but certainly not one that teaches how to program, nor how to implement a compiler. Look elsewhere for those
kinds of practical details. This book moves too fast for that.

Required Reading for Debugging and Memory Dump Analysis
Every debugging engineer needs to know how the code is interpreted or compiled. Debugging complex problems or doing memory analysis on general-purpose operating systems often requires understanding the syntax and semantics of several programming languages and their run-time support. The knowledge of optimization techniques is also important for low-level debugging when the source code is not available. The following book provides an overview of all important concepts and discusses almost 50 languages. I read the first edition 6 years ago and I liked it so much that I'm now reading the third edition from cover to cover.

Thanks,
Dmitry Vostokov
Founder of DumpAnalysis Portal
Editor-in-Chief of Debugged! MZ/PE magazine

Excellent book, but will not do the intended job
I enjoy the book very much. The author gives an over all introduction to the basics of the programming languages. It does not, however, dig deep into any specific area. To master in a specialized subject, one will have to seek help from other books.

As the author has stated, to learn all the subjects the book is covering, one will have to spend years (taking different courses in computer science). This book has include all the material to give an overall view of the big picture and the students are suppose to learn the material in 2 semesters.

I personally tend to think that the book is better suited for the experienced programmer for the reviewing purposes. Students that never have real world experience probably will feel the book to be very dry. ... Read more

Product Description
Find real-world solutions to PHP programming problems. Simplify and shorten thePHP application development cycle using the in-depth information contained inthis hands-on guide. PHP Programming Solutions clearly lays out more than 250programming challenges alongside practical solutions, functioning code, detailedexplanations, and usage tips. Inside, you'll learn to manipulate strings andarrays, work with HTML and Web pages, accept and validate user input, parse XMLcode, and resolve programming problems using PEAR and PECL widgets andextensions. Plus, you'll get detailed coverage of PHP security issues, SQLdatabase interaction, debugging techniques, and error processing. Work withnumbers, strings, dates, times, files, and directories. Build complex datastructures using PHP's array manipulation API. Use functions and classes tobuild modular, reusable code. Create, update, and cache HTML documents and Webcontent. Obtain and process user input submitted via online forms. Protect, log,and debug PHP script actions. Authenticate and track users with sessions andcookies. Traverse, validate, and transform XML documents. Store and retrievedata from MySQL, PostgreSQL, and Oracle databases. Interface with differentserver types, network protocols, and file formats. Perform efficient exceptionhandling and error processing. ... Read more

Customer Reviews (2)

PHP Programming Solutions
I purchesed this book hoping it would give good examples. NOT!!! Just another book for people who already know what they are doing. Now this is my opinion and this book did nothing to help explain the INCLUDE function or how to handle directories in php which is the help I was looking for.

A targeted PHP reference manual
PHP Programming Solutions is a good general purpose reference book targeted toward intermediate-level PHP programmers.The examples are simple and complete enough that it's possible a beginner could learn PHP from the book.

It is organized like a catalog, and quite frankly most of the information in it could be found by doing a simple Google search.But if you're like me, and enjoy having a book in front of you, I'd highly recommend it.

Something I didn't like about the examples was the heavy reliance on the PEAR libraries.For someone who's looking only to solve the problem at hand... in PHP... this will undoubtedly be adequate.Someone interested in more detailed explanations, such that the solution may be generally applied to other languages, may be disappointed in this aspect of the book, as I was. ... Read more

Product Description

This is the eBook version of the printed book.If the print book includes a CD-ROM, this content is not included within the eBook version.

A complete guide to mastering Mac OS X programming with the Cocoa APIs

The Cocoa programming environment—Apple’s powerful set of clean, object-oriented APIs—is increasingly becoming the basis of almost all contemporary Mac OS X development. With its long history of constant refinement and improvement, Cocoa has matured into a sophisticated programming environment that can make Mac OS X application development quick, efficient, and even fun.

Yet for all its refined elegance and ease of use, the staggering size of the Cocoa family of APIs and the vast magnitude of the official documentation can be intimidating to even seasoned programmers.

To help Mac OS X developers sort through and begin to put to practical use Cocoa’s vast array of tools and technologies, Cocoa® Programming Developer’s Handbook provides a guided tour of the Cocoa APIs found on Mac OS X, thoroughly discussing—and showing in action—Cocoa’s core frameworks and other vital components, as well as calling attention to some of the more interesting but often overlooked parts of the APIs and tools. 

This book provides expert insight into a wide range of key topics, from user interface design to network programming and performance tuning.

Customer Reviews (3)

Not an introductory book
This book provides a great deal of information, but the delivery is directed towards an audience that has some xcode and cocoa 2.0 programming experience already. Having said that, the discussion of mac programming is very thorough with many examples given. The text is a bit dry at times with explanations of what things are rather than how to implement them into your own works. Overall, a good reference book for things you may want to explore that you haven't gotten around to yet.

Still learning
I'm still working my way through this book. It's very thick, but so far, I've gained a solid base of knowledge on what Objective-C can do. The example code is excellent and not full of errors like some programming book's code I've bought. My only concern is that I've skipped ahead and the base is all you get really. It's up to you to fill in the blanks, and decide what to get next to learn more about Mac|iPhone programming. I'd recommend a good Cocoa book to go with this.

Good introduction for non-Mac programmers
I have a pretty solid background of C on unix and bare-metal embedded systems but I'm very new to Mac OS X; you should take that into account when you read the review.

The book has a distinct feel that it was written with the C programmer in mind. The book tells you all about the Objective-C messaging and objects but it keeps emphasising that Objective-C is not a substitute but an addition to C. If you read the book "Cocoa Programming for Mac OS X" by Aaron Hillegass you can very easily put together simple applications using XCode. However, if you have a deeply entrenched C background, you will feel lost a bit, because you don't know what's going on. Now this book tells you exactly that. It explains all the major Cocoa classes and the messaging but does it in a way that makes sense with a purely C background.

There are a couple of typographic errors in the book that are rather distracting. Code listings are line numbered and the text refers to the line numbers when it explains the workings of the code. The problem is, the numbers do not always match. You may have a listing of lines 1 to 20 and the text pointing out the clever trick used in lines 76 and 80. The code that the text refers to is all there, it's just the line numbers that are wrong. Obviously, when the text was written the author had a longer piece of code and later decided to remove all unimportant lines before the function in question, but forgot to update the references. At a few places the text simply doesn't make sense, apparently the author decided to rephrase a couple of consecutive sentences and haven't finished it. As expected, you have half-finished sentences, not forming a logical chain of thought.

Nevertheless, those problems are not show-stoppers. When you encounter them, you'll need to put some extra effort in deciphering the actual meaning or working out a listing offset. It is a distraction and a quite annoying one, but you can get the information.

Overall, this book will help you to understand the features and inner workings of Objective-C, the organisation of the major Cocoa frameworks and classes. It explains the Cocoa event system in depth and prepares you to feel comfortable with XCode even if you come from a non object oriented, "vi, make and gdb are the best development environment" centric background. After this book you can use the book from Aaron Hillegass and you will actually know what will going to happen in your code if you drag this thingy over there to that thingy in the interface builder, as per Aaron's instructions.

Furthermore, the book explains the differences between Objective-C 1.x and 2.0, the changes to Cocoa over the various OS X versions and shows how to write code that is backward compatible as well as forward compatible, i.e. not dependent on features that Apple might remove in future OS X versions. It also explains the differences between the Apple and GNU versions of Objective-C so that you can write code that is at least partially reusable on the GNU environment.

An important note: This book is not for iPhone development. Where the iPhone and OS X are different, the OS X version is explained but the iPhone is not. In such cases there is always a warning about the difference and usually some advice about achieving the same outcome on the iPhone, but you will need to consult iPhone specific documentation.

The book assumes that you are fluent in C and you have at least a vague idea about what object-oriented design is all about, even if you've never done any OO programming. You do not need to know Objective-C but, again you *do* need to know C to understand the book. Furthermore, having familiarity with event-driven programs, though not a requirement, will help. The book explains how events are delivered, but not the design philosophy behind event driven systems.

The book gives you a historical background regarding to OS X, Objective-C and Cocoa. It describes the (not always rosy) relationships between the Free Software Foundation, NeXT and Apple. It also explains how the GNU and non-GNU tools, old Apple technologies, NEXTSTEP, BSD and the Mach kernel are rolled together to form OS X. The history is written in a very readable style, telling the facts and explaining the business and politics behind the decisions. Nevertheless, this part of the book is very concise, it just "puts you in picture". The rest is highly concentrated information, written in an easy to follow, readable style but without fluff.

In summary, if you want to do OS X Cocoa development and you know your way around in writing software but you don't have an OO background then this is an excellent book, which I recommend to be read before any of the other Cocoa development books.
... Read more

Product Description
Brilliantly compiled by author Juval Lowy, Programming .NET Components, Second Edition is the consummate introduction to the Microsoft .NET Framework--the technology of choice for building components on Windows platforms.From its many lessons, tips, and guidelines, readers will learn how to use the .NET Framework to program reusable, maintainable, and robust components.Following in the footsteps of its best-selling predecessor, Programming .NET Components, Second Edition has been updated to cover .NET 2.0.It remains one of the few practical books available on this topic.This invaluable resource is targeted at anyone who develops complex or enterprise-level applications with the .NET platform--an ever-widening market.In fact, nearly two million Microsoft developers worldwide now work on such systems.Programming .NET Components, Second Edition begins with a look at the fundamentals of component-oriented programming and then progresses from there.It takes the time to carefully examine how components can simplify and add flexibility to complex applications by allowing users to extend their capabilities.Next, the book introduces a variety of .NET essentials, as well as .NET development techniques.Within this discussion on component development, a separate chapter is devoted to each critical development feature, including asynchronous calls, serialization, remoting, security, and more.All the while, hazardous programming pitfalls are pointed out, saving the reader from experiencing them the hard way.A .NET expert and noted authority on component-oriented programming, Lowy uses his unique access to Microsoft technical teams to the best possible advantage, conveying detailed, insider information in easy-to-grasp, activity-filled language.This hands-on approach is designed to allow individuals to learn by doing rather than just reading.Indeed, after digesting Programming .NET Components, Second Edition, readers should be able to start developing .NET components immediately.Programming .NET Components, Second Edition is the consummate introduction to the Microsoft .NET Framework--the technology of choice for building components on Windows platforms.From its many lessons, tips, and guidelines, readers will learn how to use the .NET Framework to program reusable, maintainable, and robust components.Following in the footsteps of its best-selling predecessor, Programming .NET Components, Second Edition has been updated to cover .NET 2.0.This invaluable resource is targeted at anyone who develops complex or enterprise-level applications with the .NET platform--an ever-widening market. ... Read more

Customer Reviews (65)

Required reading for serious .NET development
I read this book several years ago and have since returned to it every two years or so for a light re-read.I consider it a member of a very small group of elite .NET development books and often recommend it, along with "CLR via C#" and "C# in Depth", to young .NET developers looking to take the next step in their careers.

A great conceptual\cookbook reference for any intermediate .NET developer
I think of this book as a cookbook without the fat, or a concept book with some meat.The book discusses topics that are often glossed over in introductory books; exactly the types of things that a responsible .NET developer needs to understand to write efficient and stable .NET applications.

Can be considered a general, concise book on Software Programming...
Microsoft technology has generated some really good books on software programming over the years.This book is definitely one of them.The difference between this book and the others may lie in the fact that it is published by O'Reilly.This book is devoted to the latest Microsoft technology, but it is really a book that explains the basic principles behind all software programming.

You can read this book and substitute any other language, for example Java, to implement the principles elucidated.Of course, the set of software principles is much vaster than in this book, but there are not too many tomes that concisely and clearly explain the fundamental principles that have to show up in any software application.

And it also shows how elegant a job Microsoft has done with DotNet to implement these ubiquitous principles and make their usage incredibly easy.After the pain and torture of their earlier technology (eg. COM), this shines in contrast.Took me back to the joys of programming in plain old Basic and Visual Basic once upon a time.They must have done something right when the open-source advocates jump to implement their own version of DotNet.

.Net on Steroids !
A Classic Book that begins it's journey, where all books end. The true difference between a casual programmer and a disciplined programmer is more prominent in his/her code when they start using advanced features of the framework. A true programmer knows his stuff in and out and knows how to leverage the features of the framework effectively in every line of code. And to get to that level of proficiency it takes reading and practicing the concepts on daily basis. And if at all, there is any book out there, that will help you, then it is this book. A definite YES. 5 Stars.

One Of A Kind On .NET Components And C# Programming
Without any second thought I will place this book among the best books on the subject ever published. I hope everybody will agree that there are only a few books that worth reading from the beginning to the end without skipping a page. To me this is one of those rare books.
The author manages to reflect on broad architectural concepts and yet be extremely specific. He was able to present the most complicated aspects of component oriented programming and the C# language in a very simple, yet concise manner. Many complex issues that may turn off even experienced programmers are described in a way that not only are very well understood, but could easily be migrated into a working program. The author has found an absolutely perfect balance of presenting general architectural aspects of the subject he is discussing and real life implementation techniques.
I truly believe that anybody who is dealing with such aspects (to name but a few) as serialization, asynchronous invocation, multithreading, reflection, events, delegates, deterministic finalization, etc., MUST read this book.
By the way, this author has published another wonderful book on Windows Communication Foundation - "Programming WCF".
... Read more

Product Description
Authors concentrate on teaching the core Prolog, and all examples conform to this standard and will run on the most widely-used Prolog implementations. Paper. ... Read more

Customer Reviews (8)

Dissatisfied
Pros:
- Even someone with no programming or math knowledge could pick up the book, read it, and learn Prolog
- Uses ISO-Prolog
- Large section of helpful example programs

Big Cons:
(I'll give citations, only from the first 100 pages to keep things short, lest anyone think I am lying about the problems with the book)
- Frequent syntax errors *in program statements* - in Prolog, every comma and period is absolutely essential, when they are missing it entirely changes the meaning of the statement - the book misses them pretty routinely (p 81, twice)
- Frequent logic errors - in Prolog, the order of facts and rules is extremely important.The book commonly mixes things up, presenting you with programs that will not work (p 56 - note here that they are trying to give an example of what will/won't work, and they get it backwards)
- Frequent editing/formatting errors - charts, diagrams etc are fairly often on the wrong page or in the wrong location, etc.(p 48)
- Poor organization - looking through the table of contents, you would think the book is extremely well organized, but as you read it, you'll find new and important ideas thrown into random sections - if you forget something, and need to find it later, you'll probably need to re-skim the entire book.Things are almost never presented in convenient bullets/numbering, almost always in paragraph form, again, making essential ideas tedious to find.
- Confusing - I have degrees in math and computer science, and have been programming for 15 years, and I still found parts of the book hard to follow - note that it had nothing to do with Prolog itself, which is actually very straightforward, but rather with the explanations given, which sometimes seem meandering and poorly worded.
- A really short and crummy index makes things hard to find.For example, look up "atoms", a concept first mentioned on page 26, and routinely mentioned afterwards, a concept absolutely essential to understanding Prolog - the index shows that the first (and only) time it appears is on page 123.

Average Cons:
- Authors use an "arrow system" to trace Prolog decision making, I think a table system (which could easily show previous, current, and future steps, and details of each iteration) would have been better while presenting more information in a clearer fashion.
- Code re-use - normally a good thing, frustrating in this book.You might have a rule (like a function) called "mother(X)..." early on in the book, not use it for 100 pages, and then it appears again.If you want to try the program out yourself, you'll need to know the exact definition of "mother(X)...".There's no way to find what page the function was on in the index or TOC, so you find yourself spending 30 minutes leafing through the book to find it.99% of these are a single line of code, so there's really no need to reuse them, it's hardly saving any space.
- Overly complex examples - sometimes the authors illustrate an idea with 20 lines of code, when 4 would have been sufficient.It makes for a lot of extra reading and deciphering.

Small Cons:
- (This could be a pro or con - since I don't know too many people who *start* their programming experience with Prolog, I assume the reader has some experience with programming, and so list this as a con) Book is far too detailed for someone with moderate programming or math experience.This helps some people, but makes it a tedious read for others.Every concept is thoroughly explained.If you're a programmer, this gets a little old during things like variables and recursion.If you know any math, verbose explanations of predicate logic will become tiresome.In fairness, it was no doubt the authors' intention to make a "complete" introduction to Prolog, and so it is hard to criticize this.
- (Another pro/con, depending on the reader) British examples - the authors are British (or at least one of them is), and use British references in their code all the time (9th century princes of Wales, p 34; horses who won races in Britain in 1927, p 53) - if you're British this might break up the monotony and make things a little more interesting, if you're not, it just gets a little old, I'd rather see every example just use "cat","dog","mouse".

Other:
- NOT a good reference book (and it wasn't meant to be), if you know Prolog already and need a reference book, look elsewhere.This is for people who do not know Prolog.

Conclusion:
- I wish I bought a different book.BUT despite everything, I did adequately learn Prolog from this book, so will reluctantly give it 3 stars.

Highly Recommended
Programming in Prolog is a clear, precise introduction to Prolog from the ground up.

While is does start with the basics, it is an incredibly thorough text, covering all minutia of the language. The text is clear, easy to understand, and to the point, moving quickly through topics without sacrificing understanding.

I used this book as a supplementary text in an upper-division college course. After reading only the first four chapters, I knew things about the language that the instructor did not.
I highly recommend this book to any programmer of any skill level that is interested in learning the Prolog programming language.


Additionally,
The following two books were recommended in the preface of Programming in Prolog. The first as a quicker (though not as complete) overview for the experienced programmer, and the second as a language reference.
Clause and Effect: Prolog Programming for the Working Programmer
Prolog: The Standard: Reference Manual

A well done beginning prolog book
This book is a great introduction to learning prolog.I was learning prolog for neurolinguistics and AI applications.I have some facility with programming, python and C++, but am not a pro and it is not my day job by any means.I found this to be a very good basic introduction to prolog.There are a few typos, and a part on data structures where the commentary and the code it's on are switched.The book also loses pace and points and has to be plowed through.But on the whole, an excellent solid book to learn prolog a little.

The Best Book on Prolog
As good in 2007 as it was when published first time. There is no better introduction to Prolog

Excellent resource on the Prolog programming language
This is an extreme valuable book on the Prolog programming language that every computer science person should own.Prolog itself is actually a fairly simple language to learn, albeit slightly obscure.It's reputation for complexity comes from its non-standard implementation, but if you don't enter into it expecting it to look and behave like other languages then you should be all right.Once you get past the mathematics and logic, you should be able to get your mind working in that particular direction.This book is a very handy guide for getting the programmer into the Prolog mindset as well as bringing one up to speed on all the (sometimes very confused) syntax.

This book, like Prolog itself, is not for the beginning programmer.If you have a good background in logic or mathematics, then you should find this book to be very rewarding. ... Read more

Product Description

Advanced Java Game Programming teaches you how to create desktop and Internet computer games using the latest Java programming language techniques. Whereas other Java game programming books focus on introductory Java material, this book covers game programming for experienced Java developers.

David Wallace Croft, founder of the Game Developers Java Users Group (GameJUG), has assembled an open source reusable game library&emdash;a Swing animation engine that allows developers to use these techniques and put out new games very rapidly.

The open source game library also includes a reusable game deployment framework and a multiplayer networking library with HTTP firewall tunneling capability for applets. All of the code is open source, including the example games. The animation has been scrupulously tested and optimized in the Swing environment, and Croft clearly explains how the code works in great detail. The graphics and audio libraries used in the examples are public domain and may also be used royalty-free for creating new games.

... Read more

Customer Reviews (11)

Horrible book
This has to be one of the worst programming books I've seen. I've been coding in java for a few years and recently got interested in trying to write some 2D games for fun so I got this book.

The book is only useful if you want to know about the authors 2D game framework (which is horrible by the way) otherwise its useless. You won't learn much about 2d graphics in java, how to deal with images best (such as volatile images vs managed images) or anything else that is useful when trying to write a game.

Also its beyond me why the example games are so awful....you'd think if you were trying to show off your framework you'd actually make something that was nice..instead of completely hideous.

A much better book is "Kill Game Programming in java" by Andrew Davison.

Much filler,a little on Java game programming
You would assume by the title that this book was written for the experienced Java programmer who knows a little about game programming and wants to learn a lot more. You would be wrong. Instead the author wastes your time and his book's space with chapter after chapter of information that has nothing to do with Java game programming, much less advanced material. Chapter one, for example, is all over the map talking about XML, Ant, and upgrading to Java 1.4, which is no longer even the latest release of Java. Chapter two, which is labeled "Deployment Frameworks" talks about JAR files, applets, and Java Web Start. Other off topic subjects include a chapter each devoted to persistent data, the A* search algorithm, and HTTP tunneling. In fact, there are three chapters on HTTP. The few chapters that actually relate to Java game programming are not advanced at all to the experienced Java programmer who knows anything about graphics, Swing, and Java. Instead, the author spends his time talking about his own game programming framework that does nothing special and is constructed quite awkwardly from a software engineering perspective. There are two much better titles on the market right now. One is "Developing Games in Java" by David Brackeen, written in 2003. The other is "Killer Game Programming in Java" by Andrew Davison which was released in the summer of 2005. If you are serious about game programming in Java you should probably own them both, since they are both excellent and each has their advantages. For one, both show how to use Java's own features and API's such as Java3D and Java Sound to complement your game programs rather than reinventing the wheel such as this author does. I notice that Amazon has nothing on the table of contents for this book, so I offer it here for the purpose of completeness, and to help prove my point that most of the book is not applicable to game programming:
Chapter 1 Development Setup
Chapter 2 Deployment Frameworks
Chapter 3 Swing Animation
Chapter 4 Animation Library
Chapter 5 Advanced Graphics
Chapter 6 Persistent Data
Chapter 7 Game Architecture
Chapter 8 A* Algorithm
Chapter 9 HTTP Tunneling
Chapter 10 HTTP Polling
Chapter 11 HTTP Pulling
Appendix A Source Code Index
Appendix B Introducing CVS

not very satifying
I bought this book in hope to get some easy-to-use-library. what I found was a humble thing, written in old style that ignores modern java techniques (that allready were available long before this book was written).
The concept for the "reusable library" is such stiff, that using it for anything but silly pre-C64-style 2D games, you have to dig into the (sparely documented) library code, which turns out to be nearly empty, creating hulls of hulls of hulls of classes supplying most basic features.
Result of this is a collection of old fashioned (more than boring) games (hard to call them "games" indeed), that nonetheless employ a 1GHz machine to the limit (e.g. game "mars"). I profiled the game and found ~50% performance go into the artificial intelligence classes for 2 (two !) automated tanks humbly following my own tank and hardly able to hit me and ~40% for the 30fps crickeling of 12 sprites. The rest of the CPU power disapeared in the many empty hulls cascading to significant depths.
Do not buy !
PS: I'm an IT consultant since about 20 years now, who just learned his 18th programming language (java) and was in search of an out-of-the-box library !

Game Framework
Mr Croft explains his game game framework in this book. This framework is capable of handling 2D games via network, especially for mobile games. The book looks old fashing with a cumbersome layout and code examples which take a lot of space. Also the explained code seems to be old fashing, the new features of jdk1.4 are only mentioned about images, while the java.nio package is missing. Only some advanced topics are touched. This book is a good basic to enter the field of game programming in java, but doesn't lead you to the advanced topics.

Misleading title
This is not by any rate a book on advanced Java programming! It just has some very ugly 2D swing-based applications (you really cannot call them games..). Avoid like plague. Java game programming is still in a very immature stage but if you' re really, really looking fora decent book on Java game programming try "Developing games in Java" by David Brackeen. ... Read more

Product Description
"This book is…one nice and convenient package that I will keep on the shelf as a reference manual.

Customer Reviews (7)

skimpy skimpy skimpy
Skimpy coverage, the code compiles with a bazillion warnings, and for me at least the first client/server examples just plain don't work and don't provide useful enough error messages to figure out.It's not until you get to a much later chapter that you learn about debugging techniques that *might* help.This debugging information should either have been moved forward within the book, or should have been forward-referenced from the first example.Additionally the book repeats the same information over and over again, for instance in any example that calls for the use of the INADDR_ANY constant, the author explains what it stands for each and every time.This sort of repetition is simply not acceptable in a book fancying itself as somehow "definitive" yet only 300 or so pages.Furthermore, rather than covering ins and outs of actual network programming, far too much is devoted to the basics of various protocols (the first 20+% of the book), and/or security specifically (the last 20+% of the book).A better title for this book would be Linux Network Programming *Fundamentals*, and as such this would warrant 4 stars, maybe even 5 if it taught debugging earlier.As a *Definitive Guide* though it is a 2 at best; if you want truly definitive, albeit regarding Unix generally and not necessarily Linux, Stevens' "Unix Network Programming" series is the real deal.

Short, yet, Excellent.
A very insteresting book. I would like to see a more advanced version of this book in the future. It covers the basics of TCP & UDP, and helps you in choosing a suitable design/protocol for your applications, and covers everything related to network programming including security, debugging... Excellent work!

An adequate introduction to the subject
This book gives a good general overview of network programming for the Linux operating system along with the C source code used for the implementation. Therefore, individuals who prefer to do network programming in PERL will have to find another book. It is written for the beginner to network programming, but could serve as a general reference for more seasoned network programmers. Due to the straightforward way in which the authors explain the ideas, the book can be rapidly assimilated by those readers who are pressed for time and need to get to the frontiers of the subject with little delay. I only read the first 7 chapters of the book, and so this review will be confined to these.

In chapter 1, the authors give an elementary and general overview of networks. All of the discussion is very easy to understand, and should be helpful for newcomers. In particular, the idea of a port is sometimes a source of confusion for those who are new to networking, sometimes viewing them as being hardware interfaces on network devices. They are rather virtual destinations, and allow a standardization of just what kind of network traffic can be passed to and from a node.

Chapter 2 is an introduction to socket functions, a `socket' being explained as an abstraction for network communication. The Linux operating system uses the Berkeley socket interface (over TCP/IP), and the basic network I/O functions and the notion of a `socket descriptor' are explained in detail. A client/server configuration is used to illustrate the function calls utilized in sockets. Address data structures, such as `sockaddr_in', `linger', and `servent', are discussed. The authors also address the need for specifying the network byte order, so as not have to deal with issues of just how numbers are represented on a particular machine. Code is given for a simple application consisting of a string transfer from server to client.

In chapter 3, the authors concentrate on how to transfer files between a client and server but over the (connectionless) UDP protocol using `datagram sockets.' The discussion clearly points out the differences between TCP/IP and UDP in client/server network communications when doing file transfer. A very brief discussion is given for error handling.

The authors go into more of the details of protocol architectures and methods. An important part of this discussion is the difference between `stateful' servers, which maintain information about the current connections with its clients, and `stateless' servers that do not. A fairly thorough discussion is given on the different methods for maintaining state in a server, using the concept of `sessions'. The role of the HTTP protocol in maintaining a session in a stateless server is outlined, along with the role of `session IDs' for this purpose. The authors also discuss how to maintain state on the client side, using cookies, hidden form variables, and URL parameters.

The next part of the book deals with design issues and decisions and how to develop network programs that function in the client-server environment. Explicit programs are given that illustrate multiplexing, forking, and preforking, the latter of which will alleviate somewhat the costs associated with creating child processes during the initialization of the application. The authors also discuss multithreading, and its advantages in performance versus its disadvantages in stability (due to its use of shared memory). They also give the usual cautions in the use of multithreading, such as the need for mutexes when using global variables shared among threads, and when dealing with servers that must maintain a large number of persistent connections. For readers in the scientific community, a very useful section on how to deal with large amounts of data using nonblocking sockets is given.

Only a cursory discussion is given of "thick" and "thin" clients in this part, probably since the book is about Linux-based network programming. In non-Linux environments, thin-client architectures have become very important in recent years. The authors do discuss issues from both the client-side and the server-side, such as the differences between `monolithic' and `modular' clients, and the use of daemons on network servers. The advantages for using `privilege dropping" are also outlined, this being used in Web server programming for binding ports, and in giving an application superuser status.

Short, pragmatic guide to C network programming
This is a straightforward walkthrough of developing network clients and servers in C on Linux. Though many of the same principles could be applied to Windows network programming.

The book starts off with a small chapter on architecture. It quickly becomes chapters of annotated code with a few illustrations thrown in. The text is well written and the the book is short enough to make that format workable.

The last section of the book is dedicated to security. Which I appreciate since C programming is so fraught with security problems.

I recommend this book to those looking to write basic network protocols with C. Though I think it should be said that using a wrapper C++ library, or some higher level applications language for network protocol work will be advisable.

fine grained control
I'm not sure about the "definitive" claim in the book's title. But after reading the book, I'm quite willing to grant that the authors have indeed done a thorough job. The book calls to mind the now classic series on Internetworking, by Comer and Stevens in the early 90s. If you've been in this game long enough, you know exactly what I mean. Of course, Comer and Stevens were looking at unix boxes hooked to the Internet.

But, as you can see in this book, linux network programming carries over very closely to those unix versions. And both use what is basically the same IPv4, despite the massive physical buildout of the Internet.

The book's code is unabashedly C. No cute user interface to trip over. It can test your knowledge of C quite well. Partly because the coding and handling of network calls is deliberately low level. Using the book's approach, you can get a fine grained appreciation of how to talk across the Internet. Higher level languages like Java and C# come with network libraries that deliberately hide a lot of this detail. Which is good for many applications. But sometimes you might need the performance and control that this book offers. ... Read more

Product Description
Get a detailed look at the internal architecture of T-SQL with this comprehensive programming reference. Database developers and administrators get best practices, expert techniques, and code samples to master the intricacies of this programming language—solving complex problems with real-world solutions.Discover how to:Work with T-SQL and CLR user-defined functions, stored procedures, and triggers.Handle transactions, concurrency, and error handling.Efficiently use temporary objects, including temporary tables, table variables, and table expressions.Evaluate when to use set-based programming techniques and when to use cursors.Work with dynamic SQL in an efficient and secure manner.Treat date- and time-related data in a robust manner.Develop CLR user-defined types and learn about temporal support in the relational model.Use XML and XQuery and implement a dynamic schema solution.Work with spatial data using the new geometry and geography types and spatial indexes.Track access and changes to data using extended events, SQL Server Audit, change tracking, and change data capture.Use Service Broker for controlled asynchronous processing in database applications.All the book’s code samples will be available for download from the companion Web site. ... Read more

Customer Reviews (4)

Inside Microsoft SQL Server 2008-T-SQL Programming Book Review
I have used SQL Server since the 6.5/7.0 days and thought I knew enough to get by. I had various experiences with SQL Server 2000/2005, and then did not immediately use SQL Server 2008 until the Spring of 2010; I took a T-SQL CLASS using SQL Server 2008 at Mt. San Antonio College in Walnut, California. I learned a great deal that I did not previously know from Professor Shui-lien Huang, a very excellent teacher.

You can work with SQL Server, and unless you have the opportunity to have many challenges to stretch your skills, you may seemingly work in a silo and never learn all of it, which is a good reason to buy this book: "Inside Microsoft SQL Server 2008: T-SQL Programming". I am glad I had the T-SQL class before reading this book.

This book contains the typical coverage for a standard T-SQL statement, and then User-Defined Functions (UDFs), Triggers, Stored Procedures, Views, etc., but also some new things. For example, extending SQL Server by using CLR (Common Language Runtime) user defined types, the use of XML, dynamic SQL, and Service Broker for reliable, asynchronous processing, and Spatial Data (i.e. geodata).
On the subject of Spatial Data in Chapter 14, Microsoft has brought forth new data types, operators, and indexes to the database. Microsoft introduces the core spatial concepts and provides key programming constructs to successfully navigate this new feature in SQL Server 2008. There are 70 pages covering Spatial Data. Obviously, this is a heavy topic.

Because of auditing and compliance requirements, the issue of tracking access and changes to data has become much more important. This book shows how previous versions of SQL Server did take care of this to some degree, but in SQL Server 2008, Microsoft has added the following: change tracking, change data capture, Extended Events, and SQL Server Audit. The book shows provides guidance on where each of these new technologies is best used, and then goes on to show how to implement each technology.

This is not a beginner's T-SQL book, but it does cover beginner topics, as mentioned above. In addition, it covers some of the new aspects of SL Server 2008 that are more complex. This is most assuredly a valuable reference book that all T-SQL and .NET developers and database administrators should have nearby. It will give you excellent instruction and answers to your T-SQL questions.

Inside Microsoft SQL Server 2008: T-SQL Programming (Pro-Developer)
I would strongly recommend this book. Very detailed description of innovative techniques in all editions of SQL Server 2008. I really enjoyed the ease of the chapters ,and implements in discussion. Once you start reading, very addictive.

Outstanding Book Covering T-SQL Programming w/ SQL Server 2008
Being primarily a database and web developer, I feel more than experienced enough to review 'Inside Microsoft SQL Server 2008: T-SQL Programming' by Itzik Ben-Gan and others and I feel more and easily able to give this ***** and highly recommend this text.All the basics are covered in this 800 page book.It's not a teaching book that will give you all the ins and outs of database design and use, but it will show you what the major points of using SQL Server 2008 are, and how to get the most out of them.

Major topics covered are Views, User-Defined Functions, Stored Procedures, Triggers, Transactions & Concurrency, Error Handling, Temporary Tables/Table Variables, Cursors, Dynamic SQL, Date/Time usage, CLR User-Defined Types, Temporal Support, XML & XQuery usage, Spatial Data, Tracking Access and Changes, and finally Service Broker discussion.

The parts of the book that I enjoyed most were the last 6 chapters, as discussion on CLR usage, Spatial Data, and the like are limited in most other SQL Server books.I especially loved the chapter on Spatial data, a very important subject that has much, much greater support than years in the past.

If you are a SQL Server developer or admin, you owe it to yourself to take a hard look at this great book.It is written fantastic and is a great resource that I found useful from the moment I picked it up.

***** HIGHLY RECOMMENDED

One of the best books ever
Just like all the other books by Itzik Ben-Gan, this book is one of the best SQL books ever published. ... Read more

Product Description
Martin Wilde's cutting-edge exploration of the creative potential of game audio systems addresses the latest working methods of those involved in creating and programming immersive, interactive and non-linear audio for games. The book demonstrates how the game programmer can create an software system which enables the audio content provider (composer/sound designer) to maintain direct control over the composition and presentation of an interactive game soundtrack. This system (which is platform independent) is described step-by-step in Wilde's approachable style with illuminating case studies, all source codes for which are provided on the accompanying CD-Rom which readers can use to develop their own audio engines.

As a programmer with experience of developing sound and music software engines for computer game titles on a multitude of platforms who is also an experienced musician, Martin Wilde is uniquely placed to address individuals approaching game audio from various levels and areas of expertise. Game audio programmers will learn how to achieve enable even better audio soundtracks and effects, while musicians who want to capitalise on this shift in roles will gain a greater appreciation of the technical issues involved, so enhancing their employment prospects. Students of game design can practice these skills by building their own game audio engines based on the source code provided.

* Learn from an expert: the author brings a unique perspective to this subject from his experience as both a programmer and a musician
* Develop your own game audio engines: the book and accompanying CD-ROM provide easy-to-follow instructions and coding which you can apply to your own game and multi-media projects
* Keep up with the latest working practices in this rapidly evolving industry with this essential guide for both game audio programmers and audio artists ... Read more

Customer Reviews (2)

Good book,needexperience programming in C++
I've been looking for a book that would walk me through the process of creating a sound engine and this book does that but you need to know C or C++. For some reason it's not directly mentioned that you need programming experience in the editorial review or book description.
I don't think this is any fault of the author since it's assumed that if you are programming games you're probably using C or C++ already.

I'm a beginner programmer and I was looking for a book that would show a beginner how to make a sound engine. If you already know C or C++ than this would probably be a great book for you since it seems to be the only book ( at least what I could find) that shows you exactly how to create a sound engine, step by step.

No Mention that you need Windows to use the code.
I was impressed and excited with this book until I got to Chapter 3, where I discovered that I needed a Windows machine in order to build the "multi-platform", Soundtrack Manager. There was no mention on the cover, that in order to run the code on the accompanied CD, you need Windows.
I'm a composer/sound designer, and I happen to use a Macintosh like many other musicians, producers etc.
There is still useful information, but I was very disappointed that I couldn't build the Soundtrack Manager which the book is pretty much all about.
I'm sure it's a great book for Windows users. ... Read more

Product Description
ASP.NET 2.0 Programming: Problem Design Solution is aimed at describing, designing, and implementing a site much like the ones you’re probably working on or will be soon, while taking the opportunity to introduce and explain many of the new features that the new great ASP.NET 2.0 framework offers. Difficult problems are addressed head-on so you'll be ready for most of the problems you’ll typically face when writing a modern website, and have one or more solutions ready for them.

Unlike many other ASP.NET books that show examples for individual pages or features, the example in this book is an integrated end-to-end site (written in C#). The entire book and site has been written specifically for ASP.NET 2.0, to use the ASP.NET 2.0 features wherever they make sense.

The end-result is a website which features a layout with user-selectable themes, a membership system, a content management system for publishing and syndicating articles and photos, polls, mailing lists, forums, an e-commerce store with support for real-time credit card processing, homepage personalization, and localization. The book leads the reader through development of a site with:

• Account registration, personalization and theming
• News and events, organized into categories
• Opinion polls
• Newsletter
• Forums
• E-commerce store with shopping cart and order management
• Localization

Customer Reviews (68)

Practical to build entreprise level site
With this book, you can build a site with enterprise architecture and design.
Author explains how to solve real world problem clearly step by step. (Problem - Design - Solution). Worth read.
However, in user authentication part, it uses .NET default interface. More should be discussed on how to implement customized interface. It is normal to change the security feature based on business own implementation. It takes me some time to search on implementation of customized security module. Thus, I take out one star for this.

Excellent ASP.NET 2.0 book
This book is remarkable in many aspects, and the approach of studying a commercial website allows to cover a variety of very helpful techniques in ASP.NET 2.0. You'll learn many useful aspects of ASP.NET 2.0, instead of focusing on every domain of the framework. Also, the quality of the studied website exceeds the quality of many popular commercial websites throughout the web...

One of a kind
One of my worst gripes about ASP.NET books is that they routinely go over an extensive tour of every single little component, but dedicate very little time and space to each component and more importantly they do not show how these component fit together in a real application. So you are left with all pieces of the puzzle in your box, but no strategy for putting them together. Granted, most programming book even in the JSP/Strus/JSF area do only show toy examples of applications... but that's better than nothing! Well Marco has accomplished even more in this book, showing how to build and real life application.
The Beer House (a web site for an imaginary pub) has security and role management, themes, profiles,rather sophisticated strategies for data access, and shows you how to build an international site with articles, newsletters, forums, polls and even web parts! And last but not least it's a fun project...who isn't tired of the boring lifeless examples usually found in technical books? Seeing an programmer like Marco who takes joy in what he does and can mix fun and business is always a good sign....
It's clear that he has spent countless hours building various web content management systems on his own.. and he's had a great idea in putting his expertise in this book. I just wonder why more developers don't do the same thing! My only little complaint is that I would have liked to see more space devoted on how to build the UI. Yes, I know, this is not a book for beginners, but I have yet to see a book that covers how to effectively use the ASP.NET data bound controls.. they usually devote just a page or two to each, usually showing just one example of their possible uses.. and I think that there are many developers out there who could benefit from such a study, not even counting those coming from other platforms, who are veterans in OO programming and building business logic but much less versed in the intricacies of Visual Studio Wizards.
I would not buy this book right now anyhow.. because two new books from the same author are upcoming..
ASP.NET MVC 1.0 Website Programming: Problem - Design - Solution
ASP.NET 3.5 Website Programming: Problem - Design - Solution
and I am sure they will be even better than this one!

Excellent ASP.NET 2.0 title.
This book is a must read for any ASP.NET web application developer (Beginner to Intermediate). I have learned and developed quite a few new concepts and ideas in a more practical and example/goal oriented approach. Very helpfull for live application development/Project challenges. Different from other books which just talk about what is there in ASP.NET 2.0 but seldom talk about how to bring all those features together to build a complete solution. The author makes sure to give a breif overview/background of the feature before diving in to make use of it.

A must read for any ASP.NET web developer who is looking to put all the features together to build a solution! Two thumbs up..Can't wait for the 3.5 version. HAPPY CODING!

Kindle Version Feedback
The content in this book deserves better formatting. The code samples are in font so small and embedded as images. The result is that the "Zoom" feature helped little, and the code required being tethered to the laptop. I could not use this book for more than an overview. Disappointing to see that the publisher did not use text for the code. ... Read more