Product Description

“This book is required reading for anyone working with accelerator-based computing systems.”

–From the Foreword by Jack Dongarra, University of Tennessee and Oak Ridge National Laboratory

CUDA is a computing architecture designed to facilitate the development of parallel programs. In conjunction with a comprehensive software platform, the CUDA Architecture enables programmers to draw on the immense power of graphics processing units (GPUs) when building high-performance applications. GPUs, of course, have long been available for demanding graphics and game applications. CUDA now brings this valuable resource to programmers working on applications in other domains, including science, engineering, and finance. No knowledge of graphics programming is required–just the ability to program in a modestly extended version of C.

CUDA by Example, written by two senior members of the CUDA software platform team, shows programmers how to employ this new technology. The authors introduce each area of CUDA development through working examples. After a concise introduction to the CUDA platform and architecture, as well as a quick-start guide to CUDA C, the book details the techniques and trade-offs associated with each key CUDA feature. You’ll discover when to use each CUDA C extension and how to write CUDA software that delivers truly outstanding performance.

Major topics covered include

• Parallel programming
• Thread cooperation
• Constant memory and events
• Texture memory
• Graphics interoperability
• Atomics
• Streams
• CUDA C on multiple GPUs
• Advanced atomics
• Additional CUDA resources

All the CUDA software tools you’ll need are freely available for download from NVIDIA.

Customer Reviews (14)

Perfect for professional programming collections
A recommended pick is Jason Sanders and Edward Kandrot's CUDA BY EXAMPLE: AN INTRODUCTION TO GENERAL-PURPOSE GPU PROGRAMMING. It's a fine pick for advanced programming collections where parallel programming is of interest, covering a computing architecture designed to support parallel programs. Two senior member of the CUDA software platform team up to offer this in-depth coverage, perfect for professional programming collections.

Poorly executed
This book initially seemed like it would be a good set of tutorials on development with CUDA.It does roughly that, but the examples are poorly explained and more often than not require the read to go online to figure out what they just did.A book like this' strength should be precisely that it is self-contained with a full set of directions and explanations.

Definitely skip this one

Fair starting point, but definitely not the only book you should read.
I've done some work with CUDA and read a number of books and tutorials. This book does a very good job of relating the syntax and structure, but this book really doesn't go beyond showing you how to get your code to compile when using different features. It does not show you how to write efficient CUDA code (Getting a 7x speedup on a card running 960 threads simultaneously should *not" be considered very impressive. We've recently gotten >60x speedups, but using concepts that aren't covered in this text). I know the book industry doesn't turn on a dime, so I can certainly understand that no specific discussion is given to Fermi (though the book does list those cards), and there are (I think they claim) 200 million non-Fermi cards out there, so there is still more than enough reason to write apps that need to know how these "older" cards work. You really need a reference that will also discuss optimizing for register use, coalesced memory accesses, divergence, etc. in much greater depth.

So, given the low price, it's a useful buy if you prefer a book instead of going through some online tutorials. But, if you want to write fast, efficient code, don't stop at this book.

excellent introduction
Very well written, the authors (who are on the CUDA design team) seem to understand what people find confusing about GPU programming and take great pains to go slowly and explain things. Some other reviewers claim that the book is out of date at publication -- I view this as a lame complaint. This is an introductory book. If you work thorugh it and understand it, you will not have too much trouble catching up to the latest features.

Hits the mark almost perfectly (read the title)
At least one reviewer seems to have read the book, but missed the title. This is unfortunate. The book is enjoyable and informative from the start. It gives practical examples that get you started with NVIDIA hardware right away. This is an introduction, folks. The very first page describes the objectives and prerequisites, which, in brief are: provide an overview of techniques for interfacing with GPU hardware, using CUDA, using a basic knowledge of C - a pretty low threshold. It is explicitly stated that the examples are generally not intended for production use, but instead have been created with the goal of comprehension. I absolutely applaud this approach.

Although there are very nice examples, you will not find coverage of advanced strategies in parallel or high performance computing. I have the experience to appreciate the topics that are "missing", but coverage of many of those things would really be out of scope for this work, and almost certainly be a distraction.

It's very rare that an author, or team of authors take on the task of teaching a specific technology without having their effort degrade into the production of a huge, incomprehensible tome of endless, redundant screenshots and half-baked everything-to-everybody code blocks. I suspect that the participation of the team at AW had something to do with the success of this book, as I have noticed a certain pattern of solid, on-topic references from them.

In any case, if your goal is to get started, this book is for you. If your goal is to produce very high performance code - which it probably is in the future - then this book with be a great companion to others that have or will cover distributed processing theory. ... Read more

Product Description
The #1 bestselling programming book is back with updated and expanded coverage of the newest release of WoW!

World of Warcraft (WoW) is currently the world's largest massively multiplayer online role-playing game. The newest release, "Wrath of the Lich King," has created a demand for updated information on writing addons. This eagerly anticipated edition answers that request and is an essential reference for creating WoW addons.

Written by a duo of authors who have each contributed a number of successful WoW addons, the book offers an overview of Lua and XML (the programming languages used to write addons) and includes coverage of specific pitfalls and common programming mistakes-and how to avoid them. Valuable examples show you detailed aspects of writing addons for WoW and demonstrate how to implement addon concepts such as variables, slash commands, secure templates, and more.

• World of Warcraft insiders share their techniques for writing addons for both the latest version of WoW as well as the new Wrath of the Lich King expansion set
• Guides you through the specific nuances of the WoW API with the use of detailed examples
• Discusses ways to distribute and host your WoW addons so others can download and use them
• Explains how to respond to events, create frames, and use the WoW API to interact with the game

You'll be well on your way to creating exciting WoW addons with this comprehensive reference by your side.

Note: CD-ROM/DVD and other supplementary materials are not included as part of eBook file. ... Read more

Customer Reviews (5)

Excellent if you have xml xp.
This may be a bit though if you lack experience in xml. And some readers may get lost as the progression jumps ahead of what you have be able to learn from the last chapter.

Great book for programmer with a little prior experience
I needed to design a few different addons for some research I'm doing, and this book had everything I needed. You may have difficulty if you've never programmed before, but if you already have a little knowledge of programming fundamentals, this is a great tool.Highly recommended.

Perfect guide for a programmer
This is absolutely the perfect guide to learning how to program for Warcraft if you're already familiar with programming in other languages.The author covers all the right topics in precisely the right order necessary to understand the interface.He covers everything from the basics of LUA all the way to the most advanced topics (secure code) and provides examples everywhere.

Highly recommended for anybody who is serious about learning this stuff.

Great book on Lua and WoW mods
This is a huge book covering all the details of writing a mod in lua.The elements are presented in a logical method and show an actual mod being designed and programmed from the ground up (BagBuddy).This is an excellent book that takes you from a beginner mod programmer to being able to design and create whatever mod you want.If you don't want to create your own mods, the book will show you how to tweak your existing mods to make them work the way you want them to.Even after you have read the book, you will use it as a reference for quite some time as you work on your own mods.I honestly had no idea that the WoW API provided so much of the foundation for building mods.My hat is off to both Blizzard for creating such an environment that welcomes mods and definitely this book for presenting mod building to me in such a great way.The cover art is great too.

Excellent addon resource
James has been in the WoW addon field for years and his addons are second to none.Back a few years ago he took the time to help me with my first addon and I appreciated the help.I owned the first book and happy to add this one to my library.

The books are well written and contain the information you need to begin writing your own addons and more.They are excellent reference books that will keep you writing addons for a long time.They also have a website to cover any changes made to the API by Blizzard.

Plus the cover is by Scott Johnson, what more could you want.

Bouvi (Earthen Ring - AIE) ... Read more

Product Description

Sams Teach Yourself Beginning Programming in 24 Hours, Second Edition explains the basics of programming in the successful 24-Hours format. The book begins with the absolute basics of programming: Why program? What tools to use? How does a program tell the computer what to do? It teaches readers how to program the computer and then moves on by exploring the some most popular programming languages in use. The author starts by introducing the reader to the Basic language and finishes with basic programming techniques for Java, C++, and others.

Customer Reviews (26)

Required Text Book
Needed it for school, it is what it is, not sure i would buy it if i didnt need it.

I'd like to re-review this and improve the rating.
Well, after dedicating a solid month, I can say I finally have figured it out. This is a great book with only some typos. The beginning is far too basic even for a pre-teen, but if you dont know this info, you shouldnt continue in the book.

I'm happy to say I can write simple programs now, and even made one for next April Fools!

teach yourself programming
That's exactly what is written on the cover. It's a good book for the people who know noting about programming and want to enter in this exiting field. The book is well written and gives you good idea about computer programming and teach you to program in Liberty Basic Which not the best choice from my point of view but it's free.

Words from a "wannabee programmer"
As many other people in this world want to do, I want to program video games in the future. The only problem was that I had no idea how to start or where to turn to for advice. I had tried to learn over the summer of this year on how to create video games, but the books that I had borrowed from my local library said that I needed to have an understanding of C/C++. And when I borrowed a C/C++ book, I didn't really read it. So I decided to give programming up... for a while at least.

About a month ago, that itch to create video games came back to me when I was grounded. So I went back to my library and looked for a programming book that fit my needs. During my search, I stumbled upon "Sams Teach Yourself Beginning Porgramming in 24 Hours". And so I decided to read the introduction if I met the books requirements. When I learned that I did, I borrowed the book and began to read the book.

The book mainly covers a language called Liberty BASIC (which is probably is as easy a programming language as it gets). Right out of the gate, the book lets you program your first BASIC program, a rocket launch countdown. I was suprised how easy it was to program in Liberty Basic. To me, it felt like dumbed down English. When you are finished with the Liberty BASIC training (11 hours worth), you should have a good understanding of Liberty BASIC.

The book also gives you a detailed introduction to Java, but the first two chapters are only text and no examples. Those two chapters do help with the basics of Java and C/C++ (C is Java's "mother" language). When you do get to the programming part of the Java in the book (four chapters of Java in the book), you use Forte for Java (it already gives you the main code for your project). Unfortunately, I found Forte a bit intimidating at first, but when I played around with Forte a bit and got an understanding, I went through the chapters with ease.

The book also gives you a taste of other languages out there (Visual Basic, C/C++, HTML, Pascal, Javascript, and .NET) I say taste because it goes over the fundamentals of each of the languages entered there. You will find C/C++ easier to understand because of your work in Java.

There were some problems with the book that I found. First, there were some coding errors that I found. I found the most errors in Chapter 10, "Having Fun with Liberty BASIC". Most of the code I found put down on BASIC and ran could not run. How can you have fun with the program if you cannot run the code? More like "Getting Frustrated with Liberty BASIC". Also in Chapter 11, there is a sample code that seems to be bugged but isn't. When you get to the code that seems bugged (I forget which sample it was in the chapter) just expand the width of the window to get the result you want.

There were also many dry spells in the sample code for you to write down and practice. The ones that have little or no examples in them are Chapters 2-4, 12 & 13, and 16-24.

In my opinion, I would reccommend this book to anyone who is considering to explore the world of programming (either regular programming or video game programming) or anyone who wants to program but doesn't know where to begin. This book will not mold you into a good programmer, but it will lay down the necessary building blocks to becoming a regular or video game programmer.

I reccomend this book for video game programmers because it will give you a basic understanding of C/C++, the typical language of game programming (this information will be useful for other books that you have your sights on and if you get another C/C++ book, you will understand some of the subjects being talked about (arrays, literals, operators, basic C/C++ procedures, etc.)

Now I just need some help on what to do next...

What you would learn.... IF you took a class
Reads like an extended course description. Very few examples. Code examples are often incomplete so they cant be run. No real 'projects' to test any skills.

Comes with Liberty Basic (shareware) (you can download this seperately and learn more from its own help/tutorials). For the most part, you dont even need a computer to read this book. The code examples are only excerpts so you have to study them from the text in the book anyway.

What gets me more than anything is I found about 5 errors in code and text that are important! Things like mislabeled variables that would confuse anyone trying to learn. Although I guess finding the mistakes is a lesson in itself.

OK, that was the bad part, but I didnt give it a score of 1 because it is easy to read (fast). It does mention a wide range of topics, and it comes with a useable version of Basic (but only limited shareware, also there is a later version online). For a real beginner, this is one way to start off slow. It is disappointing because it could have been much better with only a little more effort. A few larger examples, and a few more actual coding projects instead of just saying'if you want to create a text box in your program, type the following line....',

and then moving on to the next lesson.

This review relates to the 2nd edition. ... Read more

Product Description

Product Description
Most of the book is devoted to discussions of individual tools, but throughout run the themes of combining programs and of using programs to build programs--emphasizing how they fit in the environment. ... Read more

Customer Reviews (34)

A required reading for all unix users
This book should be a required reading not only for beginning Linux, Mac OS X, and Unix programmers, but also for most unix users and all system administrators. Yes, this book is very out of date. Some shell and C language syntax in it might not be just out of date, it might be simply invalid under current implementations! Yet, amazingly, possibly +90% of the examples will still work on unix systems, even though the book was written more than 25 years ago. This text is not meant to be a cookbook-type source of shell and C language code snippets. The value of this text lies in its ability to convey the philosophy of the Unix environment, from users' and programmers' perspective. This book illustrates how one can combine the standard unix tools: the shell, the grep, the sed, and the awk languages to solve practical problems. It also introduces the unix toolkit for C programming and the unix documentation system.

Now, I do want to admit that some stuff in this text is embarrassingly out of date. There are some shell commands that will not work on modern Unix implementations. The C code is using the K&R C style. That's still valid syntax, but also relatively archaic and older than what's taught in the second edition of K&R. The desktop calculator written in C with help of lex and yacc is very neat, but the more advanced versions of it will not compile with a modern version of gcc (2.7.x and older). (Finding out why is a nice exercise in debugging C code, and may potentially drive you mad). The signal handling examples for the C language as presented in this book are out of date and unreliable (see APUE on the reasons for this). If the syntax of the code examples was updated to be in touch with 21st century, even without adding any new content to the book, that would still make this book the most awesome beginner Unix text written. Due to being out of date, I think it earns a score somewhere between 3 and 4 stars. This text should be followed by O'Reilly's "Unix Power Tools" and, if you intend to write Unix software, the most recent edition of APUE.

Great Unix Reference book
If are Unix or Linux geek, this book is for you...as a refernce book, specially for novice....ed

THE GOLD STANDARD!
With the growth of MacOS X and programmers looking how to take better advantage of the UNIX/Darwin/Mach underpinnings of the system, there is a great need for something to educate programmers on the basics of how to best take advantage of this environment. This book, affectionately known as K&P by some of us "old timers," continues to relevant, even after more than 20 years since its first publication.

Sure, there are more "up to date" books, but K&P's treatment of the basics are the best. The book is full of discussions on best practices and uses for common commands that are still in use today. They show how to build the constructs to make shell scripts fly, even on today's faster hardware.

The treatment of C programming under UNIX is classic. If you did not learn C by reading "The C Programming Language" by Kernighan and Dennis Ritchie (K&R), then the chapter on building a calculator with lex and yacc will be a difficult read. But other than that, this book is a must-have for anyone learning to program under UNIX!

Great book on the foundations of the UNIX environment
In spite of its advanced age, this book is still relevant and explains many topics better than much newer books on the various flavors of UNIX. Although there are better books on the specific flavors of UNIX available today, no other book does as good a job of explaining the philosophy of generic UNIX and its intrinsic relationship to the C programming language. The book starts out talking about invoking common commands from the command line, the UNIX file system, and then moves on to "filtering"- which in this context means feeding the output of one command into the input of another command until you obtain the output you desire. Next shell programming is introduced along with sed and awk, which are the oldest of the UNIX scripting languages. Finally, we exhaust what can be done with sed, awk, and scripts consisting of UNIX commands already in existence. So, the authors show us how to "roll our own" UNIX commands by writing C programs and invoking their executable versions just like a UNIX command would be invoked. This part of the book is not meant to be a tutorial on the C programming language, so the reader should already know C or have another source for learning it. As an addendum to the section on C programming and UNIX, the authors illustrate how to use the UNIX system calls to build a richer set of commands. These system calls are interfaces to the UNIX OS kernel and provide a means for the programmer/user to access I/O, create and access files and directories, process errors, manage and create processes, and handle signals - which are the UNIX version of interrupts and exceptions. The book closes with a discussion of yacc and lex and illustrates how they can be used to build a calculator for use in the UNIX environment.
This is a very "hands on" kind of book, so you should have access to a UNIX based system that has a C compiler handy so that you can type in the commands and do the exercises as you read along in the book. If you are a beginner to the world of UNIX, regardless of the flavor that you are ultimately interested in using, this is a great book to get your feet wet and to understand the power of this operating system.

The bible of Unix
This book is the best book on programming on Unix. It is very practical, and it gives you a good understanding of the philosophy of the Unix system and how to use it.

Unix is a programmers environment. Once you understand the foundation it is a very productive environment. It will show you the tools, the philosophy behind the tools, and how to be productive in the Unix environment. People who hate Unix haven't read this book or aren't programmers... ... Read more

Product Description

Customer Reviews (8)

Ótima Picareta.
Gostei muito do livro, fácil entendimento aborda deste coisa simples até mais complexas. Agrada a todos os gostos.

For advanced programmers interested in all the theory
I really didn't enjoy this book.I purchased this book based upon the reviews and my hope was to use it to get up to speed on Ruby in a rapid manner.The author makes all kinds of assumptions that the user already should know certain things.While there are many examples, they are very dense and theoretical in nature.The author spends more time giving every possible theoretical way of using a particular feature of the language and does not offer many real world examples.

I am already an experienced programmer having mastered Java, PHP, C, and Visual Basic.Still, I find the syntax of Ruby hard to understand and this book does not help.I am not going to give up on Ruby.I will keep this book as a reference and seek out some other instructional guide for learning the language.

My advice to those wanting to learn Ruby for the first time - buy a different text.

Others better
The book offers lots of detail and theoretical/algebraic examples.Very dense even on simple facets of ruby, but then gets lost in theory trying to explain moderately difficult aspects.I am a firm believer that when an individual masters a topic they can explain even the most difficult aspects in a clear way....no present contrived examples that are almost formulaic in there presentation.I'v had to read a few sections several times only to undercover the author was just trying to explain a very trivial aspect of the language.

Life changing
I used to work with PHP, C++ and Java, until I found Ruby! This book is a great pass to a bright future for programmers. Since I bought it and started developing Ruby and Rails applications, my developments skills keep getting better and the amount of time I spent coding is getting always smaller. Ruby is great to performe Agile Programming and is really a language to look for!
Highly recommended!

Great Reference for Veterans and Noobs Alike
I've been using Rails for a few years, but I never dug deeply into Ruby.This book is one of the best technical books I have read, it keeps you engaged, which is very touch to do with such a dry subject matter.I read cover to cover (except the reference in the back) and I feel very confident in my Ruby skills.I learned something new in every chapter, and have a more grounded understanding of Ruby.I have already used this book as a reference, and I expect to do the same for quite a while.

If you are using Ruby in any way, this book should be in your library. ... Read more

Product Description

As the computer industry changes from single-processor to multiprocessor architectures, this revolution requires a fundamental change in how programs are written. To leverage the performance and power of multiprocessor programming, also known as multicore programming, you need to learn the new principles, algorithms, and tools presented in this book. It includes fully-developed Java examples detailing data structures, synchronization techniques, transactional memory, and 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
“Ask a mechanical, structural, or electrical engineer how far they would get without a heavy reliance on a firm mathematical foundation, and they will tell you, ‘not far.’ Yet so-called software engineers often practice their art with little or no idea of the mathematical underpinnings of what they are doing. And then we wonder why software is notorious for being delivered late and full of bugs, while other engineers routinely deliver finished bridges, automobiles, electrical appliances, etc., on time and with only minor defects. This book sets out to redress this imbalance. Members of my advanced development team at Adobe who took the course based on the same material all benefited greatly from the time invested. It may appear as a highly technical text intended only for computer scientists, but it should be required reading for all practicing software engineers.”
    —Martin Newell, Adobe Fellow

 “The book contains some of the most beautiful code I have ever seen.”
    —Bjarne Stroustrup, Designer of C++

“I am happy to see the content of Alex’s course, the development and teaching of which I strongly supported as the CTO of Silicon Graphics, now available to all programmers in this elegant little book.”
    —Forest Baskett, General Partner, New Enterprise Associates

“Paul’s patience and architectural experience helped to organize Alex’s  mathematical approach into a tightly-structured edifice—an impressive feat!”
    —Robert W. Taylor, Founder of Xerox PARC CSL and DEC Systems Research Center

Elements of Programming provides a different understanding of programming than is presented elsewhere. Its major premise is that practical programming, like other areas of science and engineering,must be based on a solid mathematical foundation. The book shows that algorithms implemented in a real programming language, such as C++, can operate in the most general mathematical setting. For example, the fast exponentiation  algorithm is defined to work with any associative operation. Using abstract algorithms leads to efficient, reliable, secure, and economical software.

This is not an easy book. Nor is it a compilation of tips and tricks for incremental improvements in your programming skills. The book’s value is more fundamental and, ultimately, more critical for insight into programming. To benefit fully, you will need to work through it from beginning to end, reading the code, proving the lemmas, and doing the exercises. When finished, you will see how the application of the deductive method to your programs assures that your system’s software components will work together and behave as they must.

The book presents a number of algorithms and requirements for types on which they are defined. The code for these descriptions—also available on the Web—is written in a small subset of C++ meant to be accessible to any experienced programmer. This subset is defined in a special language appendix coauthored by Sean Parent and Bjarne Stroustrup.

Whether you are a software developer, or any other professional for whom programming is an important activity, or a committed student, you will come to understand what the book’s experienced authors have been teaching and demonstrating for years—that mathematics is good for programming, and that theory is good for practice.

... Read more

Customer Reviews (14)

Does not cover new ground
I was really looking forward to reading this book. Now that I'm done proving nearly all the lemmas the reader is asked work out, I have to admit to reading it with gritted teeth and what is best described as nearly constant annoyance. I will say that the subjects covered here are important and carefully chosen. The authors are undeniably passionate about the content, and they definitely know more about writing good programs than I will everlearn (particularly when said programs are written in C++). So what was it that rubbed me the wrong way?

Basically, I could not help but feel like I was re-reading old and very good ideas from the 1970's about writing provably correct and reusable programs. The book often combines these with algebraic structuresto produce efficient and reusable C++ code that is as general as possible. It does all this quite well, though it's a bit like being hit on your head with a sledgehammer at times. The code here is hardly beautiful, but on the whole it was a reminder of why the C++ Standard Template Library was such a brilliant effort. However, at the end of every chapter I felt like the focus on C++ implementations limited the discussion about what the universal "elements of programming" are supposed to be. In particular, I would fault the book on not including any material on mathematically rigorous type inference systems that have been developed since the early 1980's, particularly because types are so central to what the book discusses, andsince the book's errata online suggests the authors are dabbling with re-implementing all the code in Haskell.

The bibliographic references also suggested a certain arrogance (I cannot imagine it is ignorance): there are no references to the extensive literature on the formal verification of software. It is this tone that finally got to me, the insinuation that putting so-called software engineers on a formal mathematical foundation was something never attempted before this book was written! People have been doing it for over 40 years, but you wouldn't know it by looking at the bibliography.

In the end, whatever your programming background, if you really work through the text and solve the exercises you will definitely be better off than when you started. I know I'm glad I read it. But I'd be surprised if you really enjoyed it, or if you understood what "elements of programming" you should be looking for in your next software project (particularly if it is not written in C++).

After reading this book I had to ask myself if I would recommend earlier books that covered similar ground (which are missing from the bibliography in this book), like A Discipline of Programming or The Science of Programming (Monographs in Computer Science) (Volume 0), to a practicing programmer. In fact this book made me pull out my copy of Dijkstra's monograph and re-read it after nearly two decades. I have to say that A Discipline of Programming still impresses where this book comes across as, well, somewhatflat.

Attempt 2
My first attempt to post something here did not succeed, the review disappeared. Apparently Amazon doesn't like low-starrage reviews. Well, being a good citizen, I'll try again:

This book treats of formalised ways of thinking about logical entities you deal with in programming. No reason to be scared: the book is not difficult to understand: if you can read something like Schaum's Outline on Sets (say), you can read this book. As an intellectual warmup material, it's fine. What I can't figure out is what the hell for do I need any of it? There's no stated or discernible overall goal in this book. Everything in it looks like a pile of preparatory material for some other book.

It's not particularly well written either: there's a lot of categorical statements of undemonstrated intentionality or provenance: you bump into yet another "this is that" and immediately think: is it? not obvious... Irrespectively, why is this definition necessary? Where are we going with it? No answer. Again, imo, this book can be recommended only as a means of leisurely mental [self-pleasuring]. Any other goals, even if present, have been hidden exceedingly well by the author.

Bottomline: Ars longa, vita brevis: nor recommended. At least till someone smarter than me explains this book's motivation in concrete, specific words, not oh-so-poetic BS about "most beautiful code".

Fantastic and rigorous
This is a fantastic, rigorous approach to providing clear mathematical foundations for fundamental programming concepts. As others have noted, this is not a book for programmers looking to improve their coding (though it may help with your algorithms). It's computer science at it's purest and for programmers who are autodidacts, who skipped Knuth et al, or who just don't have a strong foundation in mathematics (or maybe forgot a lot of what they once knew), this book is both informative and a great intellectual exercise.

haphazard collection of ideas
The book uses a variety of common mathematical structures as the basis for examples of algorithms and their translation into code.In its presentations, it emphasizes mathematical and formal analysis.Examples are in C++.

However, it's difficult to see who this book is actually aimed at.The mathematical sophistication and use of C++ make it a bad choice as an introductory textbook.Few of the mathematical structures or reasoning have much relevance to day-to-day programming.The formal analysis differs substantially from standard formal methods.And mathematicians tend not to require an explanation of formal or mathematical reasoning, when they reach for a programming book, they want quick and effective software solutions.

This book may appeal to mathematically inclined C++ developers.But this mathematically inclined long-time C++ programmer never warmed up to it.I think there are better introductory textbooks, better textbooks on formal methods and program correctness, and better textbooks for mathematicians and scientists wanting to learn about programming.

Dumbells for your Programming Muscles
I wanted to find a book that would give a very formal and mathematical perspective on computer programming and that is what I got. I found this book very difficult to read. The concepts were often foreign, abstract and often described in a very terse manor. However, after reading and re-reading sections of the book it started to slowly make sense. Once I started understanding a little bit it made more and more sense and I really started to appreciate what the book was doing.

I have never come across problem solving presented in this manor before. The algorithms initially appear quite cryptic but once I read and desk-checked the algorithms they came across as quite clever - who would have thought there was so much to be said about 'power algorithm'. I would recommend this book to anyone who is up for a challenge - who can appreciate code that doesn't have an immediate application to business application development. It is certainly not an easy read and is suited to mathematically minded programmer.

That being said, I do have some complaints. Sometimes the book comes across as overly terse, they give one explanation that's it. It could have used diagrams to better communicate an idea. It lacks an explicit overarching theme and direction.

There is one warning I will give to the prospectus buyer: "The book does not have worked examples, solutions to the exercises, nor does it give proofs for all of the lemmas." This is not a real problem but it breaks the flow of the book as you have to stop and convince yourself that the information presented is correct.

All and all it is a stimulating, interesting and challenging book. ... Read more

Product Description
Provides advice, real-world examples in C, C++, Java, and a variety of special purpose languages. Includes debugging, testing, performance, portability, design, interfaces, style, and notation.Softcover. DLC: Computer programming.Amazon.com Review
Coauthored by Brian Kernighan, one of the pioneers of the Cprogramming language, The Practice of Programming is a manualof good programming style that will help any C/C++ or Java developercreate faster, more maintainable code.

Early sections look at someof the pitfalls of C/C++, with numerous real-world excerpts ofconfusing or incorrect code. The authors offer many tips andsolutions, including a guide for variable names and commentingstyles. Next, they cover algorithms, such as binary and quicksorting. Here, the authors show how to take advantage of the built-infunctions in standard C/C++. When it comes to data structures, such asarrays, linked lists, and trees, the authors compare the optionsavailable to C, C++, Java, and even Perl developers with arandom-text-generation program (using a sophisticated Markov chainalgorithm) written for each language.

Subsequent sections coverdebugging tips (including how to isolate errors with debuggingstatements) and testing strategies (both white-box and black-boxtesting) for verifying the correctness of code. Final sections offertips on creating more portable C/C++ code, with the last chaptersuggesting that programmers can take advantage of interpreters (andregular expressions) to gain better control over their code. A handyappendix summarizes the dozens of tips offered throughout the book.

With its commonsense expertise and range of examples drawn from C,C++, and Java, The Practice of Programming is an excellentresource for improving the style and performance of your codebase. --Richard Dragan ... Read more

Customer Reviews (53)

Class was full
Not sure, the course that used this book was full, so I had to go for some other course. However, I flicked through and had a cursory glance at the material and found that the positive reviews here reflect the topics I was seeing.

Good book to read
I think this is a good book to read. Recall a joke about programming:
1. Learn all the theories about computer science.
2. Pick up a style.
3. Forget about all that and just hack.

This is a joke but often times quite true. However, to become a more complete programmer, one cannot omit either 1. or 2. and go directly to 3. In fact, if you do that, you are about to see your position being outsourced to other countries, because you are so replaceable that you do not have much to offer and everyone can do your job.

This book is about 2. in the joke, picking up a style. It is not about teaching you how to write a program in a specific language. It is, however, from a pair of masters' point of view, what programming is all about and how to write code in style so that it is simple, elegant and easy to maintain.

I will quote Stroustrup here that being able to write good code is much like being able to write good articles in any language, which has no fixed way of doing it. Some natural talent and personality possibly have something in the play.

This is a good book to read. But I think for a small book its size (<300 pages), it is expensive. Also, things they talk about become kind of trivia if you have a couple years of real experience.

Great Book!!!
This book is perfect forany computer engineer who wants to get more information about programming.

Good Introduction
This book isn't bad.If you have any formal academic education in the area, you will probably want to just skip the first 2 1/2 chapters: they will have nothing new for you.

The later parts of the book cover enough topics that there will probably be some things to pick up from it here and there.This book will definitely not make your brain sweat; easy reading for a weekend you don't have anything better to do.

On the flip side, it isn't really going to give you any immediately useful skills.

Destined to Become a Classic
When I began my first career as a writer, I was constantly referred to "Elements of Style" by Strunk & White. This short, lucid, and concise handbook, written in 1957, has become the most frequently used text to instruct beginning and veteran writers how to perfect their style. "The Practice of Programming" does for software professionals what "Elements of Style" did for writers. In its short 267 pages, "Practice" addresses the basic elements of writing good source code, by consistently adhering to the principles of simplicity, clarity and generality. In a world where poor programming style is all too common, "Practice" reminds programmers that good programming style is just as important as their functionality. It is not enough that source code is executed well by the computer. It is also critical that other programmers can understand and interpret the code as well, especially during the later stages of a project when changes, bugs and integration difficulties predominate. Other books on programming are far better at teaching technique and functionality. This book shows how you can pull it all together to produce elegant, concise and compact code which optimizes both computer and human resources. As a project manager, I heartily endorse these principles to produce software which maximizes scope, cost, schedule and quality performance. ... Read more

Product Description
introductory, beginning, concepts, logical. ... Read more

Customer Reviews (21)

NOT FOR BEGGINERS!!!
This book was a total waste! I had to purchase it for a programming logic class. I did not understand much of the information presented in this textbook. It is not for a beginner and I do not know why the local community college (Ivy Tech) would have this for a begginner class. It does not teach fundamentals instead it just throws you into some sort of logic that is in between pseudocode and flow charts. The text does not even cover the exercises that are at the end of each chapter! They give you some ridiculous example and expect you to figure out the pseudocode and flowcharts! I enjoy programming but this is not the book for you! This was the first book along with our VB programming book. VB did great in PLD did aweful in. They should have picked a better book as an intro course! This book has a ton of unnecessary information in it, the assignments are not covered in the text, and moreover it is very hard to get help elsewhere because it covers neither pseudocode nor programming but somewhere in between. 800 pages of small print that could be 300. Half this book is what not to do??

Very Informative and Useful (If You're Into Programming)
Greetings to anyone wanting to purchase this text or anyone who may just be wanting some information pertaining to this text.

Although my review is brief, it is very sincere and unbiased.I purchased and used this book for a class I took approximately three (3) years ago within a Computer Networking curriculum.

The content in this text is extremely informative and thoroughly explains the basic design and configuration of computer programming language.That's as far as I reached within this text because the class' coursework was focused on a basic understanding only.I'm sure the remaining content of the text is just as well written, informative, and useful for reference as it is in the first few chapters.

However I personally find the subject matter and content uninteresting and I usually avoid advanced programming situations within my professional life (I work in the IT field).I may enter a position where I will have to use such advanced programming language, and if I do then I have a great book to reference.

In conclusion, I can honestly document that this text is well worth the purchase and it will provide to be useful for students and professionals alike.

Structured Learning
This is a great book to learn programming structure. I learned more from this book than I have from other similar books. You won't learn syntax in this book, but there are lots of flowchart and pseudocode examples that illustrate the concepts. There are example problems at the end of each chapter as well as a video learning aid.

Awesome
Straight forward like most PC/IT books. Book was in near mint condition. Arrived in just a couple days. Very in depth and comprehensive and covers alot of ground for just one book.

More than almost new...
It came with the cellophane broken.Other than that, it was a perfectly new book.Awesome. ... Read more

Product Description
Lua is the language of choice for anyone who needs a scripting language that is simple, efficient, extensible, portable, and free. Currently, Lua is being used in areas ranging from embedded systems to Web development and is widely spread in the game industry, where knowledge of Lua is an indisputable asset.

"Programming in Lua" is the official book about the language, giving a solid base for any programmer who wants to use Lua. Authored by Roberto Ierusalimschy, the chief architect of the language, it covers all aspects of Lua 5---from the basics to its API with C---explaining how to make good use of its features and giving numerous code examples. "Programming in Lua" is targeted at people with some programming background, but does not assume any prior knowledge about Lua or other scripting languages.

This Second Edition updates the text to Lua 5.1 and brings substantial new material, including numerous new examples, a detailed explanation of the new module system, and two new chapters centered on multiple states and garbage collection. ... Read more

Customer Reviews (35)

Best Ever
"Programming in Lua" is the best programming book I have ever read.

I have programmed for over 30 years and have a bookshelf full of programming books; none are comparable and few are close to the quality of this book.

Roblox's Language
It is awesome it is the programing link for Roblox to get to there check this out

geicogeko is always tinkering with witty malls on An easy way to get started
Something was in the air back in the 90s. Whatever it was, it spawned an entire generation of scripting languages, Lua among them. As with so many others, Lua has a modest type system, simple syntax, native support for tables with arbitrary indices, and many extensibility features. And, like many of the othe scripting languages, it has become the standard in at least one community of developers.

Unlike other languages, Lua acknowledges that modern programming is often a multi-lingual affair. In fact, Lua is intended for use by C programs (and for using C code) as a language within a language. That lets developers use C's strengths in low-level programming and performance sensitive parts of applications, but switch to something a bit more friendly and flexible for other parts of the code - often, the majority of it. (There's something awry about the reasoning that says "I need C's capabilities for 2% of my app, so I'll write 100% of it in C.")

Ierusalimschy's book provides a straightfoward but gently paced introduction to Lua. Power users will certainly need something stronger, but I found this a great way to see what the language is about and why it stirs such loyalty among its devotees.

-- wiredweird

All you need in one book!
This book explains it all and renders a full coverage of the most flexible and light-weight scripting languages currently available (IMHO). I would buy this book again and I would learn lua again :)

Comprehensive and well-thought-out.
This book is an unbeatable introduction to the Lua programming language, as might be expected considering it's written by the language's creator. However, the book is also an excellent guide to programming in general, because Roberto explains concepts which are applicable in most other languages. Maybe this is because Lua was designed primarily as a 'glue' or 'embedded' language. The author's ability to explain complex ideas is outstanding. You may have to re-read a paragraph a couple of times to fully 'get' it, but once you do everything just clicks.

Also, don't expect this book to be limited to an introduction to the language. That introduction is pretty solidly handled in the first 60 pages or so. For your money, you also get information on integrating your Lua code with your C code, techniques for coroutines and multi-threading, and advanced uses of the Lua table object (including object-oriented programming).

But wait -- there's more! There's a run-through of Lua's standard libraries which is not your standard printout of the online documents -- it's full of useful, progressive examples. I found the string library documentation particularly useful. Just by reading the table of contents you'll see that this is a very well-thought-out book, and I can vouch for its execution being excellent as well. ... Read more

Product Description

Customer Reviews (1)

Where is it?
THe 4 libraries where I live don't have it. Borders does not yet and I have to give a credit card for a deposit. I wont I want to pay cash. My laptop is almost here and when it arrives I will download the express edition of visual studio (Or if zealous download the super steroid verion of the professional version). BUT (softly felt) I will have to wiat until the libraries get the book. I love what I have seen so far on the amazon book preview. DELEGATES were explained better. And so were were the INTERFACES which were the 2 biggies I was looking for. In the meantime which is a groooovy time, I will wait.

... Read more

Product Description

For use with all versions of Linux, including Ubuntu,™ Fedora,™ openSUSE,™ Red Hat,® Debian, Mandriva, Mint, and now OS X, too!

Customer Reviews (56)

Good intermediate book on Linux
This is an excellent material for those who are already somewhat familiar with Linux/Unix and want to take their knowledge to the next level. This is especially wonderful book for programmers (C and Java for Linux), perl, and shell script writers.

If you want a detailed understanding of how Linux operates, however, this book falls short. For example, the book hardly covers Linux networking and security (linux groups in particular). It also provides only very rudimentry coverage of error logging and location of key system information in the /etc folder. Master Linux you will not after reading this book.

Already having intermediate knowledge of Linux, I can't say I have learned a whole lot from this book.

The quality of writing is good and the explanations are well thought-out. The author also painstakingly organized some of the most widely used Linux commands in both glossary and reference format.

If you want more advanced understanding of managing a linux server and its capabilities, then I would recommend a more advanced book. If you are a developer with little to no Linux/Unix background and want to develope applications in Linux/Unix servers, then this is a very good place to start.

Practical, authoritative, readable and educative
Excellent book that will take your linux skills to the next level. Command line is where Linux shines and if you need to know what's under the hood, read this book, either cover to cover or just by chapters that interest you.
You'll hear many Linux enthusiasts gladly pointing to free online resources for learning Linux and although there are many, those resources are of varying quality and always fail to go into a deeper discussion accompanied by examples, end up pawing man pages or worse are just echo of somebody else's attempt at writing a Linux walkthrough.
This book is primarily practical. Although the opening chapter may seem unnecessary, dealing with history of GNU and Linux, chapters that follow dive deeper and deeper to show you just what is it that makes Linux shell so great.
The language in which this book is written makes it an authoritative source. If you ever caught yourself reading the man pages of any Linux utility, you noticed how incredibly terse and hard to understand the language of the man pages can be. The language of this book is just a notch down from the man pages language, it isn't hard on you but it will require your attention all the time as there's very little to none "filler material" and unnecessary repetition.
This is not to say that this material is dry and unreadable. The material is not only compiled information on utilities and their roles but author also shows his points in practice and makes you learn not only on how- to's but by contrast as well. I caught myself reading 30 pages at once when I noticed this book on the shelves of the bookstore, just by browsing through the pages.
Educative- if you set out to learn as many available commands with their most commonly used handles, the appendices of this book will greatly help you achieve just that since those appendices contain an impressive compilation of commands, their handles and (what most impressed me) what those handles do through examples. No other book or online guide that I've seen so far does that for its reader. Commands discussed aren't only the most popular ones, or the recommended ones for different levels, inside are explanations for commands that are used by more advanced users but explained on a very plain level and through non- trivial examples. That is way past the "hello world" level of online guides.
Although you'll probably be mostly interested in the Bash shell part, author discusses other available shells with the more advanced audience in mind (like tcsh and zsh) keeping the same level and depth of discussion, and where necessary, points out how things are done or which equivalent utilities are used in those shells as well as in Bash.
What isn't covered here is Linux networking. Everything that is explained pertains to working at an individual Linux workstation. It is assumed that you have an access to a completely configured and successful Linux installation that has all hardware and installation issues resolved. In this day and age, you'd probably want to do a virtual installation of Linux in a virtual machine thereby eliminating possible conflict due to non- compliant hardware.
This book helped me a lot while preparing for the Linux Professional Institute Certification level 1, especially for the first of the two exams (LPIC 101) that required exact knowledge of commands and their usage on individual workstations. I successfully passed that exam and those appendices with commands as well as explanations provided throughout the book proved invaluable at exam time.

Major Kudos
Mr. Sobell has written another beautiful book on Linux!I first read his "A Practial Guide to the Unix System" and loved it."A Practical Guide to Linux(2E)" is also masterfully written.I come from a strong Windows/Sys Admin background.Recently, my company asked me to support Unix/Linux too.I found most books dificult to grasp and hard to read.Mr. Sobell's clear and deep understanding of Unix/Linux shines through in his book.It's a joy to read a Linux book and actually understand what's being said.I can't thank Mr. Sobell enough for writing it and helping me to have a deep understanding of Linux.

Beyond frustrating
I really wanted to like this book as I am now a regular linux desktop user and want to learn shell/perl scripting. Unfortunately this book has been a tremendous letdown. The presentation of topicsand the code examples do not build on one another and the ordering too often seems haphazard.

Readability of code samples is hindered by not numbering lines of code. It's a lot easier to read when the text says "Line 24 specifies the variable...." instead of trying to find the line referenced by "The third say statement specifies the variable....".

Most damning in my mind is the repeated sin of referencing material not yet covered in examples. So when I am reading page 200 there is no reason to throw out a code sample with material that won't be covered until page 450. This book is replete with examples like this! It's as if they had a general idea of the topics they wanted to cover, they wrote the text and code samples for each topic and only then decided on the order in which to present the information. I'm sorry to report that learning from this book is far more frustrating than it should be.

If only one advanced Linux command reference were to be chosen, this is among the top contenders
A Practical Guide to Linux Commands, Editors and Shell Programming appears in its second updated edition to provide a tutorial to the latest Linux commands and references. It's the only book to offer a primer on Perl for all system administrators, in-depth coverage of basic and advanced Linux shell programming, and tips and tricks for customizing the shell. If only one advanced Linux command reference were to be chosen, this is among the top contenders for the job.
... Read more

Product Description
A much-needed resource on database development and enterprise integration for the iPhone

An enormous demand exists for getting iPhone applications into the enterprise and this book guides you through all the necessary steps for integrating an iPhone app within an existing enterprise. Experienced iPhone developers will learn how to take advantage of the built-in capabilities of the iPhone to confidently implement a data-driven application for the iPhone.

• Shows you how to integrate iPhone applications into enterprise class systems
• Introduces development of data-driven applications on the iPhone
• Discusses storing data using SQLite, managing data using Core Data, and integrating with Web Services
• In-depth coverage of displaying data on the phone using the UITableView

Professional iPhone Database Application Programming gets you up to speed on developing data-driven applications for the iPhone. ... Read more

Customer Reviews (1)

Worth every penny
There are many excellent iPhone/iPad books out there but this title stands out because it delivers on what it is says it will do, teach data access on the device.Solid book. ... Read more

Product Description

“If you’re writing a native Win32 program or just want to know what the OS is really doing underneath, you need John’s book. He covers the stuff that real systems programmers absolutely must know. Recommended.”

–Chris Sells, Microsoft Corporation

“This fourth edition does a great job of incorporating new features in the Vista, Windows 2008, and Windows 7 API, but also stays true to teaching the foundational elements of building applications that target the Windows OS.”

–Jason Beres, Product Management, Infragistics

The Definitive Guide to Windows API Programming, Fully Updated for Windows 7, Windows Server 2008, and Windows Vista

Windows System Programming, Fourth Edition, now contains extensive new coverage of 64-bit programming, parallelism, multicore systems, and many other crucial topics. Johnson Hart’s robust code examples have been updated and streamlined throughout. They have been debugged and tested in both 32-bit and 64-bit versions, on single and multiprocessor systems, and under Windows 7, Vista, Server 2008, and Windows XP. To clarify program operation, sample programs are now illustrated with dozens of screenshots.

Hart systematically covers Windows externals at the API level, presenting practical coverage of all the services Windows programmers need, and emphasizing how Windows functions actually behave and interact in real-world applications. Hart begins with features used in single-process applications and gradually progresses to more sophisticated functions and multithreaded environments. Topics covered include file systems, memory management, exceptions, processes, threads, synchronization, interprocess communication, Windows services, and security.

New coverage in this edition includes

• Leveraging parallelism and maximizing performance in multicore systems
• Promoting source code portability and application interoperability across Windows, Linux, and UNIX
• Using 64-bit address spaces and ensuring 64-bit/32-bit portability
• Improving performance and scalability using threads, thread pools, and completion ports
• Techniques to improve program reliability and performance in all systems
• Windows performance-enhancing API features available starting with Windows Vista, such as slim reader/writer locks and condition variables

A companion Web site, jmhartsoftware.com, contains all sample code, Visual Studio projects, additional examples, errata, reader comments, and Windows commentary and discussion.

Customer Reviews (22)

A Concise Guide to Essential Windows Programming Concepts
The first thing I noticed when opening this book is that I could open the book to any section I was interested and find the information in a format that is easy to read and understand. The author clearly describes each concept and then supports the information with generous code samples (supplemented by the author's website in case the samples in the book are not enough). Within each topic, he does a good job of building up the concept, first explaining the basic principles, and then extending those basics to real world use.

This book is perfect for a web programmer like me. I have been using ASP.Net as long as it has been around, but I have only started doing Windows programming this year. I often find myself inferring how the Windows Operating System works based on my interaction with it through my code. This book provides a definitive guide that helps me to understand the underlying systems. I am a C# programmer and I was surprised to see that I am able to read and understand the examples in the book (given in C) with no problem.

I think this book is ideal either for someone looking to switch from web programming, or non-windows programming. It is also good for a programming student who wants to get into Windows programming. It would be better if the reader already has some basic programming foundation. However, the book does give enough basic description of even the most rudimentary concepts that if an initiate programmer encounters an unfamiliar concept, the book will give enough information to lead the reader in the right direction.

This book is a nice addition to my knowledge library. I would recommend it to anyone who is learning or practicing windows system programming.

Excellent book for Windows System Programming
If anybody is looking for a good technical resource to learn Windows programming "Windows System Programming by Jonathan Hart" is the best source for him. The author has clearly and cleverly joined each blocks and provided a good resouce for non experienced and experienced learner. It takes into a great detail coverage of what Windows is doing at a lower level. It is the only resource where I found practical and complete examples on real-world programming tasks, such as Named Pipes using IO Completion ports, file handling etc. Me being a hardcore .Net guy who has left C programming more than 10 yrs back, found it very helpful to understand how things work in back when you use Windows API.

The best thing is extensive code with great detail of explaination. Example code in the book are pretty good (though there were few minor issues which can be ignored).

Multiple chapters on multithreaded programming have been extremely insightful, indispensable and helpful. Johnson has done a wonderful job by providing enough information on each topic, while not loosing the main thread of thought. Overall, I pretty impressed by author deep understnading of System Programming.

I recommend this book for any serious Windows developer.

Excellent reference for Windows development beyond the .NET API
I was pleased with what I have read in this book. It is difficult to find books that cover the technical aspects of Windows programming, even harder to find a good one. This is not a book for most of the drag and drop Visual Basic crowd but if you want to extend yourself beyond the .NET environemnt then this book will be of great value to you.

Windows System Programming by Jonathan Hart is an excellent source of information
Windows System Programming by Jonathan Hart is an excellent source of information about programming against the core system services provided by the windows API.Hart does an excellent job of detailing the numerous features provided by the API, their uses, and various pros and cons of using one over another.He also details the various changes in the windows API from older versions of the operating system up to its present incarnations as Windows 7and Windows 2008.It fulfills its objectives of explaining what Windows is, how to use it in realistic situations, and not burdening the reader with unnecessary detail.The comparison of various functionality with its Unix equivalents in an effort to increase program portability was an aspect of the book I enjoyed and made me feel would be a good companion book to one of the more traditional, operating system components books that go in depth into Unix functioning.As a companion book, it could be used to give the student a feel for programming against the Windows API as well as various Unix system functions as well.
The book covers how to develop against the various operating system services provided by the API and various issues that may arise with modern day technology.The 64-bit extensions to the API and programming in a multiprocessor environment are extensively covered and the points of confusion and consideration are recognized.The method of mitigating the risks involved with using all of these enhancements are also elaborated on which provides the reader with an in-depth understanding of the issues that may possibly be encountered when using these technologies.
One of the things I found most enjoyable about this book is the level of detail the author went in to with creating the exercises and their ability to increase the understanding of the topics covered in their companion chapter. I found these problems challenging, enjoyable, and not overly difficult.One could definitely use this as part of a curriculum in a class covering these operating system concepts.

A Very Positive Experience
I read this book from the perspective of an experienced .NET developer with very little knowledge of the Windows API. I liked the author's pace; the initial introduction to the Windows API structure and conventions was detailed enough for me to understand everything without causing me to lose interest through repetition or over-simplification. The examples throughout the book were clear and concise, and illustrated the subject matter well. The reading lists were germane and referenced high quality texts - some of which have made their way onto either my bookshelf or wish list. I find it much easier to grasp concepts by "doing" rather than merely reading, so I was extremely pleased with the exercises - these were well thought out and helpful, and certainly accelerated my learning.

Many of the concepts addressed in this text are familiar to me (multi-threading, security, etc), but only as implemented through the .NET framework. Even if I never write any production code in these areas, it's made me a better .NET developer now that I have a more in-depth understanding of the Windows API. I would absolutely recommend this book to .NET software engineers - even if you never write a line of code against the Windows API directly, it will give you a much broader understanding of what Windows is doing at a lower level. Just ensure that you have at least a basic understanding of C first - this is a prerequisite. ... Read more

Product Description

Topics covered: How to use Oracle PL/SQL in all its manifestations through Oracle9i. Fundamentals of program structure (loops, cases, exceptions, etc.) and execution get attention, as do data types, transaction management, triggers, and the object-oriented aspects of the language. There's also coverage of calls to external Java and C programs. ... Read more

Customer Reviews (94)

Kindle Edition not the latest
Amazon sais that this kindle book includes 11g features, but it does not! The kindle edition is the 4th edition, including 10g features.

Oracle PL/SQL Programming: Covers Versions Through Oracle Database 11g Release 2 (Animal Guide)
With the exception of the first edition, I have purchase all others that Steve has published. Not bad for a self-confessed newby programmer. Just kidding. It is the one book I would want if I were stuck on a desert island. Of course, for a lack of firewood, well sorry Steve; we have to do what we have to do.

I have been a professional PL/SQL programmer since the mid-eighties. On one job, an earlier edition made me a hero. Today, I program for the US Army Aeromedical establishment, so I serve the heros and proud of it. My one and only PL/SQL book I keep at my side is this book. Steve, keep up the good work. It would not hurt my feelings if you wrote a book on the practical side of PL/SQL for DBAs as I find myself involved in DDL work 1/3 of my project life cycle so scripts and hints would always be welcomed.I do have a copy of Donald Burleson's DBA Scripts affectionately known as Code Depot and I take nothing away from Donald, but I enjoy the format used in the Oracle PL/SQL; it is the best even though it is just my opinion.

The "all you want to know" PL/SQL reference book
If you're looking for a book that can be your reference for every doubt you may have in PL/SQL programming, its syntax and constructions, that's the book for you. The examples are very clear and easy to understand. The author uses examples in both ways, before applying a certain functionality and after applying it, which makes comprehension much better. In case I had no PL/SQL book so far, I wouldn't waste my time buying other ones. There is only one cons: the size and weight of this book. It's not something you'll like to carry in your backpack everyday, but keeping in your shelf as a handy reference book.

Very comprehensive and thorough but heavy
It covers PL/SQL very well with many practical examples that can be readily used. The topics are comprehensive and the explanations are very clear. One problem: it's way to heavy to hold and read. I wish there is a Kindle version or eBook.

Next best thing to being in a class
If you need to learn about PL/SQL this book is the next best thing to actually being in a class. It answered so many questions and was a huge help to me. ... Read more

Product Description

Known for its versatility, the free programming language R is widely used for statistical computing and graphics, but is also a fully functional programming language well suited to scientific programming.

An Introduction to Scientific Programming and Simulation Using R teaches the skills needed to perform scientific programming while also introducing stochastic modelling. Stochastic modelling in particular, and mathematical modelling in general, are intimately linked to scientific programming because the numerical techniques of scientific programming enable the practical application of mathematical models to real-world problems.

Following a natural progression that assumes no prior knowledge of programming or probability, the book is organised into four main sections:

• Programming In R starts with how to obtain and install R (for Windows, MacOS, and Unix platforms), then tackles basic calculations and program flow, before progressing to function based programming, data structures, graphics, and object-oriented code
• A Primer on Numerical Mathematics introduces concepts of numerical accuracy and program efficiency in the context of root-finding, integration, and optimization
• A Self-contained Introduction to Probability Theory takes readers as far as the Weak Law of Large Numbers and the Central Limit Theorem, equipping them for point and interval estimation
• Simulation teaches how to generate univariate random variables, do Monte-Carlo integration, and variance reduction techniques

In the last section, stochastic modelling is introduced using extensive case studies on epidemics, inventory management, and plant dispersal. A tried and tested pedagogic approach is employed throughout, with numerous examples, exercises, and a suite of practice projects. Unlike most guides to R, this volume is not about the application of statistical techniques, but rather shows how to turn algorithms into code. It is for those who want to make tools, not just use them.

Customer Reviews (8)

Essential text in order to take R to the next level
I share the generally held view that R has a steep learning curve but the effort spent learning it is well rewarded.I study both statistics and econometrics and I find that R straddles both more easily than most statistical packages, because of its flexibility and the fact that someone, somewhere has thought about your problem and written a solution for it.However, once the fundamentals of R are grasped it is not long before one is left craving to know how to tap into the core strength of R, which is its programming capability.This is where "SP&SUR" comes into its own.It is easy to follow and builds up well.The examples are clear and easy to follow.This book is undoubtedly the key that unlocks R.Highly recommended.

The missing link for grad students
If you are a graduate student in statistics, biostatistics, or the like, and are struggling with R programming, then this book should do the trick.So many books are out there regarding how to to do DATA ANALYSIS with R. This book is not another one of those. This book is what is needed to learn to program R for statistical computing NOT data analysis, and there is a big difference. This book will prepare you for classes in statistical computing and after doing some of the exercises, you will be ready for books like Maria Rizzo's Statistical Computing with R and Givens and Hoeting's Computational Statisics. You will learn how to write loops (I know everybody is trying to avoid this) and functions and how to do simulations, numerical optimization, root finding, and there is even some goodies about graphics. The book obviously doesnt cover everything, no book could, but if you combine this book with one of the others mentioned above, then you should be well equipped for statistical research using R.

This book is easy and usful textbook
This book is useful and easy for undergraduate students in statistics and graduate students in other field.
This book motivates scientific statistical programming..
I recommend this book for Beginning level students about statistical computing.

Great Book!
I will keep this very short. This is a great book for beginners! It helps a bit if you knowsome basic programming concepts, but then that's not necessary. The book is well written, and it has great exercise questions to hone what you have learned. I will definitely recommend it to anybody starting out in R.

One of a Kind
To the best of my knowledge this is the only book its kind. The usual book reads like a stand-up comedians program of one-liners.This book gives an integrated discussion of how to write your own code to solve non-trivial scientific problems. I plan to use much of the material in a mathematics course I shall give in the fall. ... Read more

Product Description

Customer Reviews (3)

Programming the Mobile Web
This is a great reference for the experienced (XHTML/CSS/JS) web programmer who is looking to apply their skills in the mobile realm.I would liked to have seen more with HTML5 tags as this will go a long way to having on page for all browsers.

Too generic - not enough example code
I bought the book because of the other 5 star review (that happened to be the only review at the time), but was disappointed once I got to read the book.

I'm building a web-based mobile app and was hoping this book would teach web techniques that work on multiple platforms, and would save me development time by for example not having to build separate iPhone and Android versions while still being able to provide native looking interfaces for different platforms. After reading the book though, I am not any closer to that goal than I was before reading it. The book was way too generic for my needs and provided hardly any code examples I could actually use for my project. The book seems more like an academic course that teaches the principles of mobile-independent development, rather than practical advice you can put to use right away.

I admit that I probably had the wrong expectation when buying the book, and I can see that the book would have value for someone who is simply converting a traditional website into a mobile website, and wants that mobile version be accessible by as many people as possible. But for more serious web app development this is the wrong book.

Best mobile web reference I've seen
The purpose of this book is to identify best practices when creating web applications that will be consumed by mobile web browsers.It not only does an excellent job outlining those best practices, but it's incredibly up to date in its content.Not only is there information related to "retina display" available in iPhone 4, but there is also a brief discussion about how Palm has been purchased by HP (both events occurred only a few months ago).

The book begins by providing the most comprehensive discussion of mobile browsers that I've ever seen.The author furthers this discussion throughout the book by providing some of the most detailed information on the compatibility between these various mobile browsers and the standards that each one supports.The book warrants a purchase simply for this information alone.

The author continues by providing examples of supported doctypes, coding markup, and CSS.The author demonstrates CSS differences between the major mobile browsers, and demonstrates some libraries to make web applications look more like native applications.

There is a lot of attention given to Safari, and rightly so, since it is one of the most popular mobile browsers available.However, the reader should be prepared for this fact.

All in all, I found this to be a terrific reference to the state of mobile browsers and a great reference to assist in maximizing compatibility among mobile browsers.I'd highly recommend this for any developer who is creating mobile web applications.By following the guidelines outlined in this book, your applications will be able to effectively reach the largest mobile population possible.
... Read more

Product Description

Customer Reviews (5)

Good Book.
Cocoa Programming in my opinion is an extremely well written book.I have been through a lot of Cocoa books, Objective-C books and the like, this one is the best.Yes, it does assume you have some basic programming abilities, but his writing is clear and the programming is such that you realize how simple and powerful X-Code and Objective C is.The author never loses you, and when you think that you made a mistake, just read on.The next paragraph will have the solution.Very well done.Excellent Job.Gets Five Stars from me.:)I had the book at a 5 star level, but chapter 10 started to assume that you know exactly what to do.Guess what?We DON'T...That's why we got the book!I am going to continue to read the book and I hope Chapter 10 was an exception because it is still a good book.

So far, So good.
As a web developer, I was a little worried about picking up a compiled language to add to my toolbelt, since the paradigm is so much different from the normal scripting and object oriented programming I'm used to, but so far "Cocoa Programming: A quick start guide for developers" has been an excellent introduction. I am a big fan of PragProg books in general and this book is no exception. Written in a clear and conversation tone, this book is helping me get up to speed with the Cocoa framework from the very practical point-of-view of the XCode/InterfaceBuilder workflow and introducing Objective-C concepts in a way that is illuminating and not intimidating.

Its not a deep resource manual, there are other books that do that, but if you're looking to see what is like to build OS X applications, this is a great first step.

Well thought out and not rushed
Pragmatic has done it again.They once more found an author to truly tackle this ever growing important subject.Cocoa Programming, and not just on the Mac but touches on the iPhone and iPad a bit.Everything is clear and concise and easy to follow.Objective-C can be a bit daunting, but not at the fault of the author just the nature of the beast.But once you get familiar with the language idioms.Things start to fall into place and you just start to get it.

Great modern introduction to Cocoa
This is a great modern introduction to Cocoa Programming.It covers a lot of topics and really helps you get the idea behind the design decisions of the apis. It is a great overview of the many important aspects of programming for the Mac desktop.

Great Starter Book for Cocoa
In my opinion this is a great book for beginners in Cocoa. The author conceptually explains the framework for Cocoa Programming (that is to me more useful then just a programming recipe book).Yes, there are a lot of recipe like books out there for iPhone and Mac programming, but if you really want to learn how things work, this book actually will help fill in the details for you. For example this book really explains 'delegates' and 'first responder' concepts in more plain language to me then other sources I used .Also, in the recent update to the book, the author covers new and important concepts with 'blocks' and 'grand central dispatch' which are new to snow leopard.The book is a big time saver and the price was very affordable (the last I checked) . ... Read more

Product Description
"Look it up in Petzold" remains the decisive last word in answering questions about Windows development. And in PROGRAMMING WINDOWS, FIFTH EDITION, the esteemed Windows Pioneer Award winner revises his classic text with authoritative coverage of the latest versions of the Windows operating system—once again drilling down to the essential API heart of Win32 programming. Topics include:• The basics—input, output, dialog boxes• An introduction to Unicode• Graphics—drawing, text and fonts, bitmaps and metafiles• The kernel and the printer• Sound and music• Dynamic-link libraries• Multitasking and multithreading• The Multiple-Document Interface• Programming for the Internet and intranetsPacked as always with definitive examples, this newest Petzold delivers the ultimate sourcebook and tutorial for Windows programmers at all levels working with Microsoft® Windows 95, Windows 98, or Microsoft Windows NT®. No aspiring or experienced developer can afford to be without it.An electronic version of this book is available on the companion CD. ... Read more

Customer Reviews (90)

A must have book for MFC and Win32
I start learning windows programming with MFC. Very quickly i realized that to be creative in MFC you must conquer the area of Win32. I consider this book as the best in the subject. It covers a wide area of win32 and simultaneously provides a in depth descrption of the windows application layer. By using this book many of the hidden thinks in MFC were exposed on the basis of win32.

A must have book
As simple as my review's title says, this book is a must have or a "seriously need to have" if you want to learn all about windows programming.
It goes from a simple Hello world program (but very illustrative since it has the basic functionality of all windows apps) to complex multithreaded ones, an in the middle of it you'll find drawing, sound, sockets and son on.
This is the book I've ever wanted to have.

Sweet Book on Win32 API
I am fluent in C programming but was sick of being stuck with the old command counsel.I am not a serious windows programmer, I just wanted to get up and running writing programs with the windows GUI and thought win32 API would be a good place to start.I have only finished Chapter 6 (~ pg 270) of Programming Windows, Fifth Edition and I am up and running, writing simple apps and understanding the basics.I also found the following web tutorials/links helpful:
[EDIT: I guess I can't post links here so just Google Win32 API Tutorials and you should find some helpful information to complement what you learn in this book.]
I am going to continue to read this book!!!It will also make a nice addition to my programming library.

The good old days...
This may sound a little over the top to some, but I get a real wind-in-my-hair feeling when I read this book.It reminds me of the good old days of Windows programming, when all you needed was a good idea, a text editor and a copy of Petzold.No Wizards, no code bloat, no multi-gigabyte IDE doing who knows what in the background.It was a time when a programmer (that's how people referred to developers back then) would put on headphones, crank up the Rush (the Canadian power trio, not the talk show windbag), and pound out C code.The applications we produced back then ran in a dew drop of memory.We knew the how to interpret the WPARAM and LPARAM for most of the Windows messages, because we had to write the window procedures and dialog procedures to handle them, and for those we didn't know, we read the header files (imagine that) to learn more.We knew our libraries.Our code was lint-clean, small, fast, and tight.Those were the days, and we were the modern-day warriors.

This book will take you back to those days.It will show you what goes on down in the engine room of MFC.This knowledge is good to have.The code examples are in crystal-clear C.This can only make you a stronger programmer, er, I mean, developer.

Info you wont find elsewhere
This book is worth the price just for the sample software alone.But even more importantant, it is a provides information on programming Microsoft windows that is not available elsewhere.It only covers the Windows 3.1 API, and is somewhat dated.It does not describe the current .NET development, for example.But even if you are a .NET programmer, there are things done here you cannot do there.Microsoft has hidden a lot of their programming features, and this book tells how to unlock them.This is a MUST BUY for any serious Microsoft programmer. ... Read more