Product Description

Customer Reviews (26)

Good Principals - Bad Timing - Poor Focus
The programming principals in the book are sound and valid.However, the book was written based on Python 2.5 instead of Python 3.0 which is a sticking point; I say this because the original release date in late 2008 would have allowed for for at least Python 2.6, but I digress.Each project in the book builds upon the previous module that was covered which is good, however the opportunity to teach core programming principals at one time in the beginning is missed.The text is easy to read and the syntax is explained well with relevant explanations.By the end of the book, the reader should be able to make a text-based programs, a windowed program, and different forms of arcade games.I was very pleased to see the layout for a card game which no one else has done to date.However, the author presents a lot of various graphic user interface mechanisms and doesn't really focus enough on them before moving on.Several editors for python are covered as well; some are challenging to install and configure which could be discouraging.I would like to point out that the author's use of EasyGUI is great because it is easier to use than Tkinter that comes standard with Python and allows the user to make text based programs more user friendly.However, he moves from EasyGUI to Pygame (which could be a book unto itself) and then to Python Card (which needs another module wxpython).My point is that it would have been better if he had stuck with EasyGUI and focused more on one of the graphic modules instead of dabbling with all of them.I was fortunate that the book was offered at my local library.If you dont get this book, then I would recommend "Invent Your Own Computer Games with Python, 2nd Edition" by Al Sweigart which is written in Python 3 (and available as a free PDF) or "Game Programming: The L Line, The Express Line to Learning" (The L Line: The Express Line To Learning) by Andy Harris even though it's written with Python 2.

Great book! Important subject
Computer science is a very important subject in our continuously evolving world. This book is great for beginners and I think would be a welcomed challenge for any child eager to learn programming. This book does not teach python but it uses it to teach general programming skills. I am just about to start computer science at the university level and had no previous programming experience. I am half way through this book and already am amazed at how much I half learned. I will add more to this review when I begin school in August to see if this book did give me a jump start or not. This book also came with a PDF version which is very nice to use when having to type up the examples the book gives you. (So you can keep your eyes on the monitor and not look away towards the printed book)

Out-dated
This book looks great for kids, but it is out of date for the current version of Python (3.1.2). My 11-yr-old couldn't even run the first program (hello world) without tech support from his professional-computer-programing uncle. Who told us how to change the code so it would work. The simplest program needs to be changed! I can't imagine how frustrating this is going to get. The website recommended in the book is less than helpful. I would not recommend buying this book unless you have a family/friend who can offer tech support.

Great introduction programming book for kids, and adults too!
My 10 year old found this book to be fun and challenging.It is a great starter book for teaching the basics of computer programming. It has many example programs and step by step instructions for each new concept.It also includes solutions in the book and on the website that can be referred to when you just can't figure out the error in your program.Highly recommend this book.

my son is learning how to program
I bought this book for my 13 yr old son who has been wanting to learn how to do programming. So far the book has kept his attention and he has tried and is learning some of the things in the book. I think its the best money I have spent. ... Read more

Product Description
This book is a guide to Perl¿s most common Win32 extensions, grouped by their functionality. The new edition updates coverage from Perl 5.05 to current Perl version 5.6.It also includes new chapters offering critical, badly-needed information regarding security for Win32Perl, the topic most highly requested by reviewers.The appendices have descriptions and syntax of each function in the extensions covered.Each chapter makes extensive use of code segments to illustrate the use of specific functions and real world scenarios in which these functions can be used.Amazon.com Review
Core Perl is an incredibly powerful programming language thathas proved a major hit with the Unix and Windows programmingcommunity. Add a whole heap of plug-in modules, and it raises thelanguage to a whole new level of usability and usefulness.

In thisexcellent volume, author Dave Roth (who, coincidentally, is a prolificWin32 Perl module writer) thoroughly documents and explains thestandard extensions, gathering for the first time all of theinformation vital to squeezing the best from these freeware ad-ins.

From ODBC to user authentication over networks and even playing .wavfiles, there's something here to interest anyone usingPerl on a Windows-based platform. Roth even explains the intricaciesof using the Win32::API module to access dynamic-link libraries (DLLs)directly--powerful stuff, indeed.

Backed up by dozens of usefulcode snippets and examples, this is such a useful book that noself-respecting Win/Perl hacker should be without it. ... Read more

Customer Reviews (20)

Good but dated
Good book to have if your are doing Perl program on a Windows Platform.The book is getting a little long in the tooth but much of the information is still useful.Maybe it is time for a new edition.

great book
I wish it were a bit more modern but thankfully almost everything that worked in nt also works in vista :-)

This book is a must have for the perl windows user. If only I had gotten it earlier.

A good summary of Win32 administration
While this book is old and maybe showing it's age on some topics (and perhaps missing some new technologies) it summarizes and explains lots of stuff. For example, you may know how to use OLE/COM but the Automation chapter explains the terminology and what are all this objects are doing behind the scenes in a Perl perspective.

I also think that this book needs a new edition with updated content and perhaps with some new chapters.

Simply the best book for the Win32 Libraries
Win32 Perl Programming: The Standard Extensions is, without question, the best scripting book I have ever owned. It has a partner book, "Win32 Perl Scripting: The Administrators Handbook" and between the 2 of them I can pretty well complete any task I need to using Perl. Some of the modules have been slightly updated since the 2nd edition, but a quick look at cpan will solve any of those rare situations. I cannot recommend this book enough if your a Windows Administrator and have ever wondered if Perl could be benifical to your evironment.

A must-have in your Perl library
If you are doing Windows programming, and you've been suffering through trying to figure out how to enumerate the machines and users in your domain(s), change passwords, gather accounting information, etc., then you MUST have this book.And you should probably book mark the author's homepage,..., as it has a slew of programs and utilities. ... Read more

Product Description
Effective awk Programming provides complete coverage of the gawk 3.1 language as well as the most up-to-date coverage of thePOSIX standard for awk available anywhere. Author Arnold Robbinsclearly distinguishes standard awk features from GNU awk (gawk)-specific features, shines light into many of the "darkcorners" of the language, and devotes two full chapters to exampleprograms. A brand new chapter is devoted to TCP/IP networking with gawk. As the official "User's Guide" for the GNU implementation of awk (gawk), it describes in an integrated fashion theextensions available to the System V Release 4 version of awkthat are also available in gawk. The book is also availableelectronically, and can be freely copied and distributed under the termsof the Free Software Foundation's Free Documentation License (FDL). Aportion of the proceeds from sales of this book will go to the FreeSoftware Foundation to support further development of free and opensource software.Amazon.com Review
For anyone who writes scripts in the awk family of languages, the third edition of Effective awk Programming provides an in-depth guide to processing text files with plenty of working sample code. Whether you are starting out with awk or are an experienced developer, this book will help you extend the reach of your awk scripts.

This tutorial covers the entire spectrum of awk script development: From the basics of opening, searching, and transforming text files, to a comprehensive tutorial for regular expressions, to more advanced features like internetworking. The focus is on the practical side of creating and running awk scripts, and there's plenty of hands-on advice for installing and running today's awk (and gawk).

The book begins with the fundamentals of awk for opening and transforming text flat files. The coverage of regular expressions, from simple rules for matching text to more advanced options, is particularly solid. You learn how to add variables and expressions for more intelligent awk scripts, plus how to parse data into records and fields. You'll also find out how to redirect output from awk scripts to other programs, a useful technique that can cause awk to get a lot more done in real applications.

Later, you learn several valuable sample awk scripts that mimic existing Unix utilities (like grep, id, and split), plus samples for counting words in documents and printing mailing labels, and even a stream editor. This grab bag of sample code lets you try out the techniques presented earlier in the book. Other sections look at support for networking in today's gawk; for example, how gawk can read and write to URLs on the network almost just as easily as local files. Full sample code will teach the beginner or expert how to get productive with networks and awk. Final appendices trace the evolution of the awk language and show you how to download and install gawk.

Suitable for beginner and experienced awk developers, Effective awk Programming, Third Edition, is an extremely worthwhile source of information on a wide range of programming techniques for today's awk. --Richard Dragan

Topics covered:

• Introduction to the awk programming language
• Running awk scripts
• Basic file processing
• Tutorial for regular expressions
• Strategies for matching text
• Dynamic regular expressions
• Parsing data into records and lines (including separating fields and handling multiple-line records)
• Using print and printf for printed output with awk (including format specifiers)
• Redirecting awk scripts output to other processes
• Basic and advanced awk expressions (constants, variables, and function calls)
• Patterns
• Shell variables and actions
• Arrays (including multidimensional arrays and sorting)
• Built-in and custom awk functions
• Internationalizing and localizing awk scripts
• Advanced gawk (communicating with other processes and networking programming)
• Running awk and gawk
• Sample awk scripts
• Internetworking with awk
• History and evolution of awk
• Downloading and installing gawk

Customer Reviews (5)

Old Reliable AWK
Every once in a while I am told to panic and get something done in an unreasonable amount of time.When the "something" involves text processing I sometimes return to AWK, and last night it saved my bacon once again.This book has never quite given methe sort of reader experience I'd hoped for, but it does get the job done and can help you do the same.

Excellent tutorial & reference that zeroes in on awk
This book explains both the awk language and how to run the awk utility. You should already be familiar with basic system commands, such as cat and ls, as well as basic shell facilities, such as input/output redirection and pipes. This book describes the awk language in general and also the particular implementation of awk called gawk. gawk runs on a broad range of Unix systems and has also been ported to Mac OS X, MS-DOS, Microsoft Windows, and VMS.

Many people are familiar with O'Reilly's book on sed and awk, but not this book. If you want to zero in on awk and its capabilities, this is really the better of the two books. It makes an excellent tutorial and reference for system administrators and anyone else that wants to use awk to extract and format text. The following is a description of the book from the context of the table of contents:

Chapter 1. The awk language and gawk - talks about the basics including how to run awk, when you should use awk, and starts you off with a few simple examples.

Chapter 2. Regular expressions - introduces regular expressions in general, and in particular the flavors supported by POSIX awk and gawk.

Chapter 3 Reading Input Files - describes how awk reads your data. It introduces the concepts of records and fields, as well as the getline command. I/O redirection is first described here.

Chapter 4. Printing Output - Besides basic and formatted printing, this chapter also covers I/O redirections to files and pipes, introduces the special filenames that gawk processes internally, and discusses the close built-in function.

Chapter 5. Expressions - describes expressions, which are the basic building blocks of awk patterns and actions.

Chapter 6. Patterns, Actions, and Variables - Each awk statement consists of a pattern with an associated action. This chapter describes how you build patterns and actions, what kinds of things you can do within actions, and awk's built-in variables.

Chapter 7. Arrays in awk - describes how arrays work in awk, how to use array elements, how to scan through every element in an array, and how to remove array elements. It also describes how awk simulates multidimensional arrays, as well as some of the less obvious points about array usage. The chapter finishes with a discussion of gawk's facility for sorting an array based on its indices.

Chapter 8. Functions - describes awk's built-in functions, which fall into three categories: numeric, string, and I/O. gawk provides additional groups of functions to work with values that represent time, do bit manipulation, and internationalize and localize programs.

Chapter 9. Internationalization with gawk - describes the underlying library gawk uses for internationalization, as well as how gawk makes internationalization features available at the awk program level. Having internationalization available at the awk level gives software developers additional flexibility - they are no longer required to write in C when internationalization is a requirement.

Chapter 10. Advanced Features of gawk -a "grab bag" of items that are otherwise unrelated to each other. First, a command-line option allows gawk to recognize nondecimal numbers in input data, not just in awk programs. Next, two-way I/O, discussed briefly in earlier parts of this book, is described in full detail, along with the basics of TCP/IP networking and BSD portal files. Finally, gawk can profile an awk program, making it possible to tune it for performance.

Chapter 11. Running awk and gawk - covers how to run awk, both POSIX-standard and gawk-specific command-line options, and what awk and gawk do with non-option arguments. It then proceeds to cover how gawk searches for source files, obsolete options and/or features, and known bugs in gawk. This chapter rounds out the discussion of awk as a program and as a language. While a number of the options and features described here were discussed in passing earlier in the book, this chapter provides the full details.

Chapter 12. A Library of awk Functions -One valuable way to learn a new programming language is to read programs in that language. To that end, this chapter and Chapter 13 provide a good-sized body of code for you to read, and hopefully, to learn from.

Chapter 13. Practical awk Programs - presents a potpourri of awk programs for your reading enjoyment. The first part describes how to run the programs presented in this chapter. The second presents awk versions of several common POSIX utilities. These are programs that you are hopefully already familiar with, and therefore, whose problems are understood. By reimplementing these programs in awk, you can focus on the awk-related aspects of solving the programming problem.

Chapter 14. Internetworking with gawk - describes gawk's networking features in depth, including a number of interesting examples and the reusable core of a gawk-based web server. The chapter is adapted from "TCP/IP Internetworking with gawk", by Jürgen Kahrs and Arnold Robbins, which is a separate document distributed with gawk.

Thus chapters 1-11 form a tutorial and reference on awk itself, and the last three chapters are additional material for reference or your own personal toolchest of programs. The last chapter is more of a curiosity than anything, since I don't know anyone who does internetworking with gawk, but it is still interesting material. I highly recommend this book if you plan to use awk extensively.

This book is an essential for people writing unix scripts and doing system administration
Awk is a powerful tool to perform search, and pattern matching on the strings/files.

This book is an essential for people writing unix scripts and doing system administration.

It gives you insight on how things work, and has very nice examples and tricks to perform the tasks.

Mostly the majority of the tasks are covered in the beginning, and the deep rooted tasks, are covered in the later chapters.

Most Complete Coverage of Awk
Awk is one of those handy Unix tools with which you can easily impress people. Using a simple

/pattern/ { action }

syntax, you can construct powerful one-liners. Do you want to how much time in total you spent surfing the Internet? Here it is:

awk '/Connect time/ { s += $8 } END { print s }' /var/log/messages

It doesn't get much shorter in any other programming language, does it? Need to strip text of HTML tags? Need a frequency count of words in a text? Awk is the perfect tool for tasks like this. With its pattern-action structure, powerful regular expression mechanism, associative arrays and basic program flow control, it provides a powerful tool for manipulating flat text files. Even though other scripting languages may be richer in features, there exists a niche where Awk is just the right tool to do the job.

Arnold Robbins, the author of this book as well as of several other books on Awk, serves also as the maintainer of GNU Awk (gawk for short), the most influential version of Awk available today. With the version 3.10, released in 2001, GNU Awk became richer for a handful of new extensions over traditional Awk, most important among them are the TCP/IP networking and the support for internationalization. All new extensions are described in the book. How successful these new extensions will be is doubtful, however. Networking scripting niche is already well covered with Perl and Python, and internationalization doesn't really matter much in short throw-away scripts Awk is usually used for.

With all due respect to the creators of Awk and their book (Alfred V. Aho, Peter J. Weinberger, Brian W. Kernighan, The Awk Programming Language, Addison-Wesley, 1988), I have to say that "Effective Awk Programming" is probably the best Awk tutorial on the market today. If you are serious about learning Awk, you shouldn't be without it. If you are still hesitating whether it wouldn't be wiser investing those 28 USD elsewhere, here is chance to read it before you buy it: install GNU Awk 3.10, and the Texinfo source of the book comes with it. But sooner or later you will find O'Reilly RepKover binding too tempting...

awk programming
This book is being picked up by the O'Reilly people. I have many of the O'Reilly books on my book shelf. There will be a third edition due out in July with Robbins as the author. I read though this book and thought it as good or better than the "Sed & awk" book that O'Reilly presently has out. Robbins is also an author on this book. I thought the book to be better than the "AWK programming language" by Aho, Kerninghan and Weinberger, the original authors of the AWK language. I recommend the book to beginers as I am. ... Read more

Product Description
Covering X11 Release 5, the Xlib Programming Manual is a complete programming guide to the X library (Xlib), the lowestlevel of programming interface to X. In addition to explaining how to handle the concepts involved in Xlib programming--such as events,graphics, and window management--this guide presents examples of both simple and complete client applications. Includes introductionsto internationalization, device-independent color, font service,and scalable fonts.This manual is a companion to Volume 2, Xlib Reference Manual. ... Read more

Customer Reviews (7)

Buyer Beware!
In this listing, Amazon has listed two separate publications under a single ISBN.0937175269 is the ISBN of Volume One - The Xlib Programming Manual.
Volume Two is the Xlib Reference Manual, and the ISBN of that book is 0937175277.
At this time, Amazon does not have a listing under the ISBN of Volume Two, but simply lists both titles under a single ISBN.But, since O'Reilly sold the two volumes separately, and Amazon lists the ISBN of only the Programming Manual, it's unclear what you would get if you were to order from this listing.Since books are uniquely identified only by the ISBN (and not by title), the buyer should probably expect to get the volume that is identified by the specified ISBN (The Programming Manual).

Before the animal books there were the "X Books"
O'Reilly and Associates was born as a publisher of technical books when Tim O'Reilly printed out copies of the first edition of this manual and was practically mobbed at a technical convention by eager customers in 1988. This is an extremely well written book on programming with Xlib, an X Window System protocol client library in the C programming language. Xlib contains functions for interacting with an X server that allow programmers to write programs without knowing the details of the protocol. Few applications use Xlib directly anymore.Instead, they employ other libraries that use Xlib functions to provide widget toolkits such as Xt, Xaw, Motif, GTK+, and Qt. However, if you are going to need to program in Xlib directly, this is an essential book. The table of contents is as follows:

Chapter 1 Introduction - This chapter gives the big picture: what X is all about and some fundamentals of how it works.

Chapter 2 X Concepts - This chapter introduces the concepts that underlie X programming. You should read this chapter even if you are the type of person who likes to jump right into coding.

Chapter 3 Basic Window Program - Every Xlib program has a similar structure. This chapter shows a simple calculator program that puts up a window and handles events in that window. You can use this simple application as a template for your own more complex applications. All clients will use the techniques described and demonstrated here.

Chapter 4 Window Attributes - The window attributes control a window's background and border pattern or color, the events that should be queued for it, and so on. This chapter describes how to set and get window attributes and provides a detailed description of each attribute.

Chapter 5 The Graphics Context - The graphics primitives supplied with X are quite simple. Most of the details about how graphics are to be drawn are stored in a resource called a graphics context (GC). GCs are stored in the server, thus reducing the amount of information that needs to be transmitted for each graphics request. This chapter describes how to use GCs and provides details on each member of the XGCValues structure.

Chapter 6 Drawing Graphics and Text - This chapter describes the routines used to draw lines, geometrical figures, and text. It also discusses the use of the pixmaps, images, and regions.

Chapter 7 Color - This chapter describes how to use color in your programs. Color handling in X can be more complex than in other graphics systems because of the need for portability to many different types of displays. This chapter starts with the basics, and gradually moves to more advanced topics, including R5 device-independent color.

Chapter 8 Events - Events are central to X. The fundamental framework for handling events was given in Chapter 3, but this chapter gives much more detail, both on selecting events for a window and on handling them when they arrive. It discusses each of the masks used to select events; for a description of the event structures themselves, see Appendix E.

Chapter 9 The Keyboard and Pointer - This chapter not only describes how to handle keyboard and pointer events but also describes many other topics related to these two input devices. In particular, it discusses X's use of keysyms as portable symbols for character encoding, keyboard remapping, keyboard and pointer "grabs," and keyboard and pointer preferences.

Chapter 10 Internationalization - This chapter begins with a detailed overview of the goals, concepts, and techniques of internationalization, starting with ANSI-C internationalization and progressing to the R5 internationalization features. After the overview, each section covers an individual topic in X internationalization.

Chapter 11 Internationalized Text Input - The first two sections provide an overview of the internationalized text input model used by R5, and are valuable to any programmer writing internationalized applications. The remaining sections describe the Xlib functions and datatypes for internationalized text input, and are quite detailed.

Chapter 12 Interclient Communication - As a multi-window environment, X must support a mechanism for communication between applications. There are three: properties, selections, and cut buffers, all of which are described in this chapter. The special case of communication between an application and the window manager is also covered here.

Chapter 13 Managing User Preferences -It is a fundamental part of the X philosophy that the user, not the application, should be in control of the way things work. For this reason, applications should allow the user to specify window geometry and many other characteristics both via command line options and in a file that specifies default preferences. This chapter discusses the use of the resource manager, which helps an application to evaluate and merge its own default with user preferences.

Chapter 14 A Complete Application- This chapter describes and demonstrates these techniques with a real application, basecalc. The basecalc application is a programmer's calculator that allows integer calculations in binary, octal, decimal, and hexadecimal and conversions between these bases.

Chapter 15 Other Programming Techniques - This chapter discusses a few orphaned techniques that didn't quite fit in anywhere else. The routines and techniques described here will not be needed in most programs. The end of the chapter contains information about porting and portability.

Chapter 16 Window Management -This chapter discusses the design of a simple window manager, not so you will be able to write one, but so you will know what to expect from one. A window manager is a program implemented with Xlib to control the layout of windows on the screen, responding to user requests to move, resize, raise, lower, or iconify windows.

Appendix A Specifying Fonts
Appendix B X10 Compatibility
Appendix C Writing Extensions to X
Appendix D The basecalc Application
Appendix E Event Reference
Appendix F The Xmu Library
Appendix G Sources of Additional Information
Appendix H Release Notes

X11 programming is complex, this book helps
Unfortunately, X11 programming is extremely complex.This book is not perfect, but does guide you through the labyrinth.If you are going to program in X11, you need to get this book.

Unfortunately there are no alternatives..
This book is a basic introduction to programming X11 directly with Xlib. It is not obvious that Adrian Nye is the best expert to learn from. Often it seems like he wrote the book in an attempt to try to make sense of the X11 system himself. Parts of it are extremely unclear, but at least we should give him credit for trying to explain everything, even those parts he wasn't entirely sure about.

It would probably be a good idea if O'Reilly made a revised edition, rewriting some of the bad parts (which should probably be clear in Adrians head by now), and updating some material for X11R6.

On the good side, there are plenty of code-examples, and while they aren't exactly showing good style, at least they are complete, you can type them in and run them. And they are all small enough to understand without further refactoring. And while not every explanation Adrian makes is crystal clear, it is definitely necessary to have some understanding of basic X11 concepts before you move on to the reference manuals.

If you want a programming manual, and not simply a reference for Xlib, this is the only book available. And while it is far from perfect, it will be much better to learn from than e.g. Scheifler & Gettys. But you'd better order that one as well.

this book is awful!
you'll never get past page 100. this book is simply unreadable.after reading a few chapters, you'll find that you've learned a lot, but understand very little.and certainly won't be able to DO anything withit. the book is guilty (amoung other things) of giving VERY technicaldefinitions which is fine, but no attempt is made to give a betterunderstanding of the term in basic, frank language that everyone canunderstand.in addition, the book is way too long.it attempts to be atreatiste on the subject of xlib.if you want to learn xlib (or anything,for that matter), you want a basic book, not a treatiste. ... Read more

Product Description
Written by a pioneer in the field, this is a thorough guide to the cost- and time-saving advantages of Flow-Based Programming.It explains the theoretical underpinnings and application of this programming method in practical terms. Readers are shown how to apply this programming in a number of areas and how to avoid common pitfalls. This is a revision of the original book, describing a number of related approaches and uses of the technology that have developed since the book first came out. ... Read more

Customer Reviews (1)

TFlow based programming - it is the future?
This is the single most valuable book on programming that I purchased in the last ten years.

If you are a programmer writing conventional programs using standard programming languages such as C++ and Java you've probably learned the hard way that concurrency is hard, that code usually isn't reusable, and that translating design into actual programs is a lot of work.There is a better way; it's called flow based programming.

In this book Morrison explains the principles of flow based programming.Conventional programs are structured around the flow of control; flow based programming is based upon flow of data.In FBP applications are developed by creating a network of components.Each FBP component acts like independent mini-process with input and output ports.Information is transferred between components using data flow channels.Systems are built by specifying the flow of information in the system.

Flow based programming promises easy and natural concurrency, real reusability, and easy translation of design into code.It's an attractive idea, but does it work?Morrison says yes and shows us how and why.This is a distillation of decades of experience with real life systems.It talks about structuring components, structuring networks, and building applications.

It also discusses the relationship of the flow based paradigm to other programming paradigms such as object oriented programming and functional programming.In the final sections it surveys other languages and projects that are conceptually related.

The one complaint that I have with the book is that it does not have an index.

... Read more

Product Description

Customer Reviews (10)

Excellent Book
This was my first Dino's book. Though this book was not the top-rated ASP.NET book, I took a chance. I am glad I did it, I love the book, I love his writing style. I recommended it to a colleague and he liked it too. I must admit that I have become a fan of Dino.

I have couple of other ASP.NET books too. This is the only one that I keep going back to refer.

Comprehensive source of information about ASP.NET
This book is an excellent source of information about ASP.NET 2.0 to 3.5, for developers new to ASP.NET and experienced ASP.NET 2.0 developers. I picked the book to prepare for the 70-562 exam. Even though the book does not contain verbatim texts and exercises to prepare you for the exam, it contains all the required material and teaches you how to use ASP.NET 3.5.

I found very useful the chapters about HTTP handlers and HTTP modules as well as the chapter on the ASP.NET page life cycle. The author uses accessible language to describe complex topics.

The AJAX programming part of this book is rather weak. It covers mostly UpdatePanel. This is good enough to get you going from ASP.NET 2.0 and to get you through the certification, but is not sufficient to write good AJAX applications in ASP.NET 3.5. For a deep dive in AJAX I recommend "Developing Service-Oriented AJAX Applications on the Microsoft Platform" by Daniel Larson.

Dino - Best ASP.NET Advanced Topics Books on the Market
I own Dino's last book (Programming ASP.NET 2.0 Applications Advanced Topics) and this book continues his excellence in writing about advanced topics in ASP.NET.There are many things that he covers that you come across on a day-to-day basis and he explains those topics well.

The topics in this book are not simple.That's why sometimes I think people who have reviewed this says it can be a hard read.Well, again that's because the topics are NOT SIMPLE.When you are diving into creating your own custom controls, Virtual Path Providers, Asynchronous Commands & Callbacks, Http Handlers and the rest, of course the language is going to have to be pretty verbose...there's not really a good way around this unless you're going to write a 1000 page Head First type of book that explains it in more simple terms.

You will search the internet for a while trying to find this kind of information.I don't know how many times I have opened Dino's book to find what I'm looking for especially when we need to create custom providers, controls and to just really understand the processing of asp.net and all the low-level details that can really become overwelming.Dino does a nice job by not overly explaining things (since you could to way into depth on many of these advanced topics) but also does not leave you short in most of his sections.

His examples are more real-world also as well as his explaination and solutions while talking about a topic.I have been at 3 .coms and all of us used his book to figure out how to do a lot of advanced tasks quite literally by him explaining (examples Virtual Path Provider, custom Http Handlers, etc.).

He also takes the time to show you diagrams more than any book I've ready on the processes.I appreciate this time he has put in to the books he writes.He doesn't just write, he diagrams a ton in his book and this is important because the concepts here are very dry and you can get lost very quickly in all the things that happen behind the scenes in ASP.NET at a very low level.

Anyway, not sure why people are complaining about the expectation of perfection when this book provides a better review of advanced topics than you'll find in any other book as well as the internet itself in a lot of cases.

It's pretty much the Bible for our team in terms of advanced topics for ASP.NET.When in doubt open Dino's book.

good overview
like the book says, there's no step by step in there but, it's a good over view of the differences however few there are in 3.5

Good overview of technology with some poor design tips
The book is pretty well tooled to ASP.Net 3.5. But it is as much a marketing pamphlet for Microsoft as it is a resource for ASP.Net programming.The author also seems to have some really terrible understandings of OO design.Early in the book he states that you should always favor base classes over interfaces.Sometimes base classes are favorable to interfaces but the founding principal of all common OO design patterns is that you should code to an interface and not an implementation.Frequent use of classes instead of interfaces can create unwanted dependencies on implementations that do nothing more than facilitate unnecessary coupling.Do a little more research before considering any of the design recommendations that the author suggests. ... Read more

Product Description
If you are new to programming with Microsoft Access VBA and are looking for a solid introduction, this is the book for you. Developed by computer science professors, books in the for the absolute beginner(TM) series teach the principles of programming through simple game creation. Covering Access 2007, Microsoft Access VBA Programming for the Absolute Beginner focuses on VBA programming, but also covers beginning database concepts for those who lack that cursory knowledge of relational databases and/or Microsoft Access. Topics range from beginning SQL concepts, user interface upgrades, new data types, essential programming constructs, and much more. The book not only shows you how to apply the concepts learned to real-world Access 2007 scenarios, but by the time you finish the book, you'll be able to apply the basic principles learned to the next programming language you tackle. ... Read more

Customer Reviews (16)

Review within context
This book starts with a great explanation of how VBA is tied directly toward enhancing an Access database.Programming concepts build upon themselves in each chapter with an end of chapter exercise.The work is involved for those not exposed to programming and moderate for those with some object oriented programming experience.In the beginning a lot of discussion must be taken for granted with the 'I believe button' pressed often for the inexperienced.But this gray area is quickly cleared up toward the end when all the building blocks start fitting together.All end of chapter programming exercises relate toward some type of game to make the final key takeaways for a chapter fun and exciting.

There have been reports already made that it isn't for a beginner but be wary of these accusations!Programming at any degree requires an individual to understand discrete logic.If you're serious about learning VBA for access this is a great primer.It will lead toward a fundamental understanding of VBA allowing for more advanced programming books such as Access 2007 by WROX and Access Inside Out by Viescas to make more sense.

Don't buy this book
I purchased this book from Barnes and Noble because I was stuck with VBA. I sat on a chair at B/N and on cursory reading in the shop all seemed well after all the book is in its 3rd edition; it was also for Absolute Beginers.

The truth is that the title for Absolute Beginers is anAbsolute Lie. I think the author wants newbies to buy this book.

The book is poorly written, many examples just do not work.

On the other hand if you know the basics of Access VBA say by learning from a primer like the dummies book, this book can be great. But for beginers, my advice is that you should not spend the money. I know it is not the money but the frustration it will cause you.

Computer books are notorius for errata and poor writing. I have learned that the best course is to have a small library of books, where you can learn a bits and peices. I am still looking for a one book that teaches everything about access VBA.

Do not buy the book. A good alternative for beginers is Access 2007 VBA byScott Diamond

M Khan

Me. They explained and then they moved on. I like it.
I have never used VBA as I have no background in programming. I called in my wife, look at this darling as I made very simple magic on the computer. I have not completed the book yet. I am still working on it, but I am enjoying it. I started at chapter three where the actual programming started and got on with it.

I have spent some time reading "Access 2003 Inside Out" so I was a seasoned beginner with Access basics. I do like this book and I will recommend it for people who want to start at the beginning and move on from there.

Good luck and good hunting.

Traveling HT

Great for beginners
I have tried several books to help me with coding in Access and was never able to full grasp it. This book made the basics very easy to understand. I even found better ways to code in VBA through this book than I had learned from other people that we considered seasoned experts in VBA. I would suggest this book for anyone that has never programmed in VBA and those of you that have been thrown into a position at work that you have to design a DB or taking over someone else's project. A majority of the information can be used in prior version of access as well.

One of the better programming books I've read
This book is pretty fun to read.That being said, it is certainly not geared towards those who know nothing of Access.

Knowing both VB and Access fairly well, I was looking for a book that would show me how to integrate VB functionality into Access applications.This book does that pretty well.

Before purchasing this book (or any other programming book for that matter) I recommend skimming the first three chapters and the table of contents to determine whether the subject matter is acceptable to you.
... Read more

Product Description
The step-by-step tutorial to learning C++ programming! Novice and experienced programmers will find this book necessary for quick and easy learning. ... Read more

Customer Reviews (6)

Excellent for absolute beginners
If you are thinking about learning how to program in C++, this book is for you.I've used many books and must say that this is definitively the best book for absolute beginner.Greg goes at a nice pace that's easy for most to pick up.Book introduces program flow controls, scopes, functions, basic I/Os, arrays and pointers and touches up on object-oriented programming.Review questions and review excercises at the end of each chapter are helpful in testing your knowledge of a particular chapter.If you are looking for extensive OOP that book is not for you, otherwise a beginner cannot go wrong with this book.

Great book to begin
If you have absolutely no idea of C++, this is a great book to begin. Though it does not cover much (any) of OOPs, its a nice book to get you hands wet with. This book can easily be read over a couple of days. I strongly recommend Greg Perry's sequel to this book "Moving from C to C++" for a neat understanding of OOPs. I read these two books and was doing great in my C++ course. The nice thing about these two books is that it gives the reader a nice conceptual understanding of why C++ is doing many of the things that is does as against C.

The best c++ book I have read on the subject.
Out of all the souce books I have on C++, this book is without a doubt the most user friendly and comprehensive that I have found.I consider myself lucky to have come across it.Obviously, the author not only knows hissubject, but also knows how to write for the reader.For once, a book thatpurports to be for beginners is written for the beginner.If you can getyour hands on this book, do it.The book stops at OOP which is a very goodplace to change course and speed.

Simply the best book there is for learning C++
I've tried learning C++ from many books from various authors. Many startedout well, and, by so doing, led me to a false belief that they wouldactually teach me the language. Each time, I came away frustrated. Perry'sbook is, however, the one and only exception I have thus far found. Notonly does it start out well, it STAYS that way. It genuinely teaches youC++. I find myself actually looking forward to reading and studying fromit. This is simply the best book written to date on C++. Now, if I couldonly get Perry to write one on Visual C++, I would really be in business!

Wanna learn C++...this is the book!!
This book is an excellent book for learning C++.It teaches you thefundamentals, and it will keep you coming back for more and more readingbecause you are learning something about the language.I highly recommendthis book to anyone who doesn't know anything about C++.I can't believeI'm learning C++!Buy the book, you won't be sorry. ... Read more

Product Description
This book clearly explains the concepts of multithreaded programs and showsdevelopers how to skillfully construct efficient and complex applications. From basic thread synchronization using mutexes and semaphores, to advancedtopics like creating reusable thread pools or implementing a deferredprocessing queue, the book uses real-world applications and carefullyconstructed examples to illustrate the principles of multithreadedprogramming. Some of the topics covered include:

• How the Windows operating systems handle threads
• Multithreading primitives in the Win32 API
• Techniques for generating thread-safe dynamic link libraries
• Advanced techniques for thread synchronization
• Basic scenarios for building multithreaded user interfaces

Customer Reviews (11)

Win32 Multithreaded Programming Review
Good overview for how most operating systems work.In depth implementation overview for the different type of kernel objects that can be used via Win32 API to sync your windows threads.Good examples of syncing situations.

A lot of useful techniques
I do not deny that the style of writing can be terse at some points. However this book covers a lot of ground on how to write a good , thread safe codes. The class included has provided a lot of usable codes that can be used in complex sowftware projects.

A very good book on multithreading
I have not seen a better book on multithreading than this one...

Ok book... but wrapper class is more of a distraction
The first five chapters are above average.I considered the wrapper classa distraction from the main topic and would have preferred more examples. This book is definately not for the novice and would be better for theexperienced MT programmer whose looking for a quick refresher.If you arelooking for a beginner's MT book keep looking as this one is not for you.

This one is a Keeper
Here's what I liked about the book:

(1) It provides simple explanation of central concepts and issues around multithreaded programming. This knowledge is platform independent.

(2) Provides clear explanation ofWin32 specific API and Kernel Objects, knowledge that is necessary to doMultithreaded Programming on most Microsoft Platforms.

(3) Builds asimple C++ based OO Wrapper class Library for Multithreaded programmingthat elegantly conceals Win32 APIs idiosyncrasies.

(4) Also buildsadditional higher Level OO Abstractions (like Monitors) that Win32 does notneed to support directly but Programmers need often.

(5) Greatillustrations of Multithreading problems, solutions and Patterns throughthe trailing part of the book.

(6) Code and Diagrams abound.

What'sthere not to like? ... Read more

Product Description
A programmer's guide to creating and using VCLs, Delphi's version of custom controls. VCLs (Visual Component Library objects) can literally be "drawn" onto an application as it is built--automatically producing and inserting code as they are placed. This book covers the use of VCLs as well as building several VCLs from scratch. ... Read more

Customer Reviews (1)

Chap 3 is usefull
TComm: a very usefull component, but errors are invoked within WindowsXP.. ... Read more

Product Description
Your ultimate guide to building graphical Linux UNIX applications with Gtk+ 1.2. Includes comprehensive coverage on Gtk+ 1.2, GLIB, and GDK. Softcover. ... Read more

Customer Reviews (4)

Sensible Reference for Gtk+-1.2 outside of GNOME
This book has a fairly clean layout. The index is a bit tepid, but Ok. So far, for content, the book is slightly better than the other two books I have seen. Donna Martin's doorstop for SAMs is pretty good, but a bit winded. Eric Harlow's book is also good, but too lean. I see a Jack Sprat pattern there.

I consider this book a good reference, not a tutorial. I like a book that does not waste too much time on the ubiquitous 'Hello World', crawling its way up to an excruciating sample application. I do not have an affinity to that style; Even for tutorials. Usually open source is replete with examples anyway.

I often judge a book by seeing if it can quickly answer a specific question, which did not immediately leap to my attention, from the standard Web docs. How do I change the text label on a button? What do the arguments really look like? Having figured it out already, I noticed this book answers the question right out of the contents page and on page 179, with an example of the proper object property arg "GtkButton::label". It is more pleasant to learn from brief working examples, than syntax diagrams and source code.

Another feature that jumped out was the "API Synopsis" sections. Fast, single sentence descriptions followed by the API call, on a class by class basis. Nice touch.

An IMPORTANT note on ergonomics, which you cannot possibly experience by clicking 'What's inside':This book is fabricated with the same lightweight, semi-gloss, low-acid paper that another one of my favorite books, Stroustrup's C++ opus, is published with. This means the book is thinner, taking up less shelve space. More importantly, the pages turn easily, indexed by finger, and when browsing the inner meat of the book, it stays open without coaxing. This means I don't have to constantly interrupt my browsing both machine and book to crack the binding. This kind of babysitting quickly vectors toward the intolerable, in particular, with the big, cheap doorstops. Good reference books need to be browseable in random fashion, right out of the shrink wrap.

A note to Logan: Nice job. On the second edition, put a bigger index in the book. It might be nice to see your "Synopsis" block style description of the most popular signals for widgets (table 4.2)and containers (table 10.1) in the signal chapter, as well as the classes. It saves flipping.

Good Reference for "Real World" Programming
My first impression after I purchased this book was that it would have limited usefulness.However, after about two weeks on my first GTK+ project it became clear that it was actually the most useful of three books I had purchased.After having this book for more than a year, it is what I turn to about 85% of the time when I have a GTK+ question.If this book has a weakness it would be that it doesn't mention much about the GNOME desktop.However, for "real world" programming on a GTK+ based project that will last more than a couple of weeks or go beyond the basics, this book is a timesaver.I also have the book by Peter Wright that covers GNOME and is a fairly useful supplement to this book.

overly tedious with no real target audience
First off, I'd like to explain why I'm judging this book so negatively. I gauge all computer texts against one of the best instructional books I've come across in my 12 years of programming; "C Programming: A Modern Approach" -- by K. N. King. This book explains the c language with out using too much jargon....

"GTK+ programming C" on the other hand is so jargon laden, it becomes tiresome before the first chapter is even complete, and what's worse, no "target audience" is ever addressed. This book is not for a novice in any way shape or form (though the back cover would lead you to believe otherwise). I'm not a novice, but I'd rather spend my time reading an instructional book with a little personality rather than one that seems straight from a man page, but enough of my opinion laden book bashing let me back up some of my accusations:

--Jargon (this is straight from the book BTW)--
"Gtk+ (via Glib) allows applications to load shared library code at runtime and execute routines that the shared library exports." say that three times fast. Again I'm being a little more critical of writing such as this because no target audience is ever specified. A novice programmer might find a sentence such as this a little confusing.

Another point of contention I have is the lack of GOOD example code. The book is seeded with function definitions, and code snippets throughout, but has very few actual examples to drive the new information home. As an example lets look at chapter 3 (Signals, events, objects and types). This chapter is about 50 pages long and is devoted to the functions that allow a Gtk+ program to interact with the OS, but this entire chapter (Very important subject matter) only included 2 (that's right TWO) working examples. Oh, the example code isn't commented either!!!

A) That is a poor programming technique in general, and
B) Comments in the code help those trying to learn the language to understand the what's, and why's, as they read the code (or type it in)

Anyway, I could go on like this for some time, but I think I've made my point. Novices and maybe Intermediate programmers stay away. Strong intermediate programmers, or better, looking for a REFERENCE, not an instructional manual, this book might be for you.

Great GTK reference
When it came time for me to make the transition from the nice and cozy world of Windows/MFC to X Windows, I started to scrounge for an X toolkit to develop applications on.As a result, I searched for decent documentation.

This book tries to be a primer and a reference, but it really only succeeds as a reference.This book covers the straight GTK code from a C perspective, and documents most of the basic widgets.

With only this book, you will find it difficult and tedious to produce usable applications.

However, armed with glade, a glade tutorial, and this book, you can be as productive in designing X GUIs as a Visual Basic programmer.

Highly recommended. ... Read more

Product Description
Extreme Programming (XP) is a radical new approach to software development that has been accepted quickly because its core practices---the need for constant testing, programming in pairs, inviting customer input, and the communal ownership of code---resonate with developers everywhere.Although many developers feel that XP is rooted in commonsense, its vastly different approach can bring challenges, frustrations, and constant demands on your patience.Unless you've got unlimited time (and who does these days?), you can't always stop to thumb through hundreds of pages to find the piece of information you need.The Extreme Programming Pocket Guide is the answer. Concise and easy to use, this handy pocket guide to XP is a must-have quick reference for anyone implementing a test-driven development environment. The Extreme Programming Pocket Guide covers XP assumptions, principles, events, artifacts, roles, and resources, and more. It concisely explains the relationships between the XP practices. If you want to adopt XP in stages, the Extreme Programming Pocket Guide will help you choose what to apply and when. ... Read more

Customer Reviews (6)

XP Programming Starts Here!
This guide is very concise & straight to the point. Do not be fool by its size.Team and project managers along with business analysts should find this guide very useful.This pocket book is an easy read that packs enough meat to get you going with Extreme Programming.It is written for anyone who is interested on knowing about XP.

By the end of the book you'll have a clear understanding of why use XP programming, practices, events, roles, code principles & style.Best of all, it provides you with clear examples and suggestions on how to adopt this methodology.

Quick and dirty review
I bought this book as a desktop refresher on XP practices.It does that just fine.If you are looking for an in depth book, you need to go elsewhere.This is a reference guide to use as a refresher from time to time on how to implement XP practices.

Concise Intro to XP
I needed a break recently, so I pulled this tiny work off the stack of review books (now 30 books high) and blasted through it in a short hour.

It's short, sweet, to the point, also injected with the occasional XP Dogma Line such as if you don't implement all 12 practices then you're not doing real XP and your manhood will shrivel or your womb will be barren.I get tired of that line, but the rest of the book is truely golden.

It's concise and lays out great sections on why one should consider XP, roles in XP, artifiacts, and a few others.The real wealth is the section on XP practices where the 12 tenets are laid out in concise, reasonable fashion.These practices are clear and understandable without a bunch of mystical handwaving or badly-written example scenarios I've suffered through in a couple other XP books.(Roodyn's Extreme .NET comes to mind as a painful example of that.)

The book's conciseness and focus makes it a perfect tool if you're trying to sell XP to your management, team, or co-workers.

great summary, ties together complex topics from best sources
I think this book should be required reading for anyone exploring XP. I introduced XP into a research lab of a dozen students and professionals, using the original books as reference. However, things would have gone much more smoothly had I simply read the pocket guide. Excellent!

Very good concise guide...
In today's world of tech books that are hundreds of pages long, it's nice to see a short, "no fluff" guide to a subject that is actually usable.This book fills that bill nicely.

Even if you've read about and implemented XP in your shop, there are times you need to review one of the points about how it all works together.Since the author covers all the main points of XP, you can quickly find the information you need.You also get a nice cross-reference at the end of each chapter that shows how each point relies on other parts of the methodology.I find this very useful if you are faced with having to modify XP for your use.It's recommended that you implement XP in its entirety, as it's meant to be more than the sum of its part.But if you have to tweak something, you know how it will affect the other areas.

I would not recommend this book as your only resource if you were just starting to implement XP.You really need to read Extreme Programming Explained by Kent Beck.He's the founder of XP, and that book goes into much more detail as to the whys of the process.But this book is one that each member of the team should have to keep the concepts fresh.

This is a very good book to use as a supplemental reference or reminder guide if you're using the XP methodology.If you were looking for a concise explanation of XP, this would also work for you.If you were looking for a more in-depth explanation of the methodology, I would recommend one of the books by Kent Beck. ... Read more

Product Description
There are several other books on programming for Mac OS X, but none of them comtain explanations of how to leverage the powerful underlying technologies. This book goes down to the real nitty-gritty of multi-threading, interprocess communication, networking, performance tuning, distributed objects, queues, Bonjour, authentication, the keychain,and directory services. The tools are also covered: gcc, gdb, subversion, Shark, and Saturn. ... Read more

Customer Reviews (11)

A bit dated but excellent content
A must have for any serious MAC OS developer. Written in 2005, some of the content in this book is dated, mostly those chapters related to Frameworks and performance tools. However the book mostly focuses on the internals of MAC OS which is a mature unix platform that hardly ever changes over the years. Therefore most of the content in this book is still very much relevant to current MAC OS.

Fills in a lot of gaps
This is a book that is about Mac OS X programming. Its easy to forget its title and expect that it would be advanced Cocoa programming but that is not the intent and therefore not what it delivers. What it does do is provide a lot of details regarding programming OS X apps and various aspects of the system that you don't find elsewhere. The primary aspect of this book that I liked was the fact it filled in many little gaps that I definitely needed filling.I definitely recommend this book for those who want to fill in those gaps like I did.

Awesome Book
If you want to know about the finer details of Mac OS X Programming, this is the book to get.This is, by far, the most detailed book on the subject available on the market.The author does an excellent job of covering all of the most pertinent topics to the nth level.If you want to be a hardcore Mac OS X programmer, get and read this book!!

Excellent information, but full of typos
This book is full of excellent information which is hard to find anywhere else, but it is also unbelievably full of typos. As I'm reading, I come across at least one or two mistakes per page! You'd think they could have taken the time to proofread it, especially considering that this is the second edition.

Odd format... great content... scary title
When I first received this book, I was intimidated by the advanced topics in the table of contents and also the format of the book. It looked painfully dry and highly complicated, but as I started reading the book, I realized it is very reader-friendly. This books very well describes the unix tools for version control, testing, and development. There is a very useful chapter on subversion which gives enough introduction to get things rolling. It also provides topics on os X technologies that you won't find in other books such as Bonjour, Multi-Processing, and Keychain management. I think it is an essential complement to any Cocoa development book.

Advanced topics are described with a very easy language and I was able to read almost half of the book in a few days, and trust me, I'm a slow reader. I recommend this book to all Mac OS X programmers and Cocoa Aficionados. ... Read more

Product Description
Ruby is an increasingly popular, fully object-oriented dynamic programming language, hailed by many practitioners as the finest and most useful language available today. When Ruby first burst onto the scene in the Western world, the Pragmatic Programmers were there with the definitive reference manual, Programming Ruby: The Pragmatic Programmer's Guide.

Now in its Second Edition, author Dave Thomas has expanded the famous Pickaxe book with over 200 pages of new content, covering all the new and improved language features of Ruby 1.8 and standard library modules. The Pickaxe contains four major sections: An acclaimed tutorial on using Ruby. The definitive reference to the language. Complete documentation on all built-in classes, modules, and methods Complete descriptions of all 98 standard libraries.

If you enjoyed the First Edition, you'll appreciate the new and expanded content, including: enhanced coverage of installation, packaging, documenting Ruby source code, threading and synchronization, and enhancing Ruby's capabilities using C-language extensions. Programming for the world-wide web is easy in Ruby, with new chapters on XML/RPC, SOAP, distributed Ruby, templating systems and other web services. There's even a new chapter on unit testing.

This is the definitive reference manual for Ruby, including a description of all the standard library modules, a complete reference to all built-in classes and modules (including more than 250 significant changes since the First Edition). Coverage of other features has grown tremendously, including details on how to harness the sophisticated capabilities of irb, so you can dynamically examine and experiment with your running code. "Ruby is a wonderfully powerful and useful language, and whenever I'm working with it this book is at my side" --Martin Fowler, Chief Scientist, ThoughtWorks ... Read more

Customer Reviews (62)

waste of time and treasure
This book is about the worst reference book I have ever purchased.At no point does it give a complete picture of the information it is trying to portray.For example on page 585 in the reference section, it talks about the Process.kill built-in.However, it does not list the signals that one might use use with this command and it does not specify anywhere in the book.It makes no attempt to be complete and much of the data you need to learn a feature such as the syntax for something simple like "if" is spread out in unrelated examples throughout the book.Badly written and incomplete.The only reason it got 1 star is that is the minimum possible rating.

Programming Ruby
I found this book to be very informative. I am new to Ruby however I have read many other programming books. This book is comprehensive a very good guide for examples for code and most of all the book is laid out in a very comprehensive way. I had no problems finding code concerns that I had and needed to understand. This book is for the serious Ruby programmer.

Great but...
Great read and I am loving the language. BUT there are no exercises for one to practice with!ARGH.

It would be a far better book if there were exercises so one could practice the concepts just learned.It one thing to go "Yeah, I get that" but it's another to be able to reproduce it with the right syntax etc.Anyway, not to diminish the greatness of the book but it whetted my appetite for more Ruby but left me hungry.I ended up using PythonChallenge.com but it's not mapped to the book so it made it a little more difficult to learn.

Firmly Planted Near The Keyboard
I acquired the "Pick Axe" book a few months after beginning to work full time on a rails application.Prior to doing so I was thrutching my way around with various Rails books, but quickly realized I needed a solid reference to the language behind the framework.

Enter Programming Ruby-
This book has most definitely become a major resource in my daily work in Rails.Being somewhat new to the language, the pick axe book always seems to hold the answers to my small inquiries about Ruby quickly and effectively.

As such I highly recommend that any Rails developer pick up this volume and add it to their library.

Must have for any Ruby programmer
I'm not sure how much the times have changed, but I got the second edition of this book on pre-order. At that time it was a fantastic references. It told me everything I ever wanted to know about the Ruby language. From the nice tutorials at the beginning to the excellent language and API reference toward the back. It even goes into some of the nitty gritty implementation details and has a chapter on writing C extensions. ... Read more

Product Description
The next major advance in the Web?Web 3.0?will be built on semantic Web technologies, which will allow data to be shared and reused across application, enterprise, and community boundaries. Written by a team of highly experienced Web developers, this book explains examines how this powerful new technology can unify and fully leverage the ever-growing data, information, and services that are available on the Internet. Helpful examples demonstrate how to use the semantic Web to solve practical, real-world problems while you take a look at the set of design principles, collaborative working groups, and technologies that form the semantic Web. The companion Web site features full code, as well as a reference section, a FAQ section, a discussion forum, and a semantic blog. ... Read more

Customer Reviews (10)

OK, but you need some foundations
The other reviews are basically correct, this is a good, broad overview and will get you up and running quickly.Beware, however, that the examples are poorly edited: for example, the namespaces used the text, the illustrations, and the source code are frequently different. This isn't too big a deal if you have some background w/RDF concepts in general and know how to debug these inconsistencies, but if you're truly a noob, you may run into some trouble.

Clear conceptual explanations, helpful examples
Semantic Web Programming is the best book on the market.I flipped through two or three other textbooks before being recommended this book by a colleague.I am so glad I found this book.

The differentiating feature of Semantic Web Programming is the frequency of visual images that help to explain the core programming concepts.The examples are also very helpful.

This book gets my highest recommendation.I am sure you will find it useful.

Best Semantic Web Book to Date
As a programmer, it's sometimes frustrating to consistently books written in research/ academic vernacular when you are trying to enhance your knowledge base from a functional standpoint. Semantic Web Programming was recommended to me by someone who swore it was the "real deal", as it were. I have to admit, I was dubious, since many of the other books "written for programmers" were either far too basic, or far too based in theory rather than practicality. I am extremely pleased to report that Semantic Web Programming is precisely what it claims to - an excellent tool for learning semantic web with the programmer in mind. I can't recommend this book enough, quite frankly, and found it to be an excellent purchase.

Brought me from clueless to confident in a month
I was tasked earlier in the year with investigating ontologies and semantic web technologies, with the expectation of producing a working application (demo) by the year's end (for a mobile R&D group).I spent a few months reading white papers as well as a book "Semantic Web for the Working Ontologist".Neither was of much use to an absolute novice.Luckily, my manager dropped this book off on my desk in July, which was an absolute godsend.Over the next month or so, I worked my way through all of the well-written chapters and example code.It took a while, but I am now confident with my work tasks ahead.I could not say that at the beginning of July.If you devote the time, I'm positive that you'll get a firm grasp of the subject matter.

Broad coverage and lots of code examples
This book will help you acquire knowledge or skills in: the Semantic Web approach to Information Modeling, the use of rules to augment such models when needed, where to find data sets already formatted for Semantic Web usage or ontologies that you could adapt for your application if you don't want to create one from scratch, how to interrogate the Semantic Web using special browsers or browser plugins, search engines, or a query language such as SPARQL, how to use an open-source tool such as Protege from Stanford University to create Semantic Web Information Models, an open-source reasoning engine like Pellet for making inferences flowing from your data sets, and an open-source development framework like Jena from Hewlett Packard for creating Semantic Web applications.

This is not the only book written for software developers but it is the best available so far, especially if you are a Java Developer.Toby Segaran et al's "Programming the Semantic Web" uses Python as the main programming language and has more limited coverage of Semantic Web topics.Both books, however, are quite readable even if you are not a programmer.If you're really looking to learn just the concepts, however, you might want to consider "A Semantic Web Primer 2nd Edition" by Grigoris Antoniou and Frank van Harmelen, or "Introduction to the Semantic Web and Semantic Web Services" by Liyang Yu, instead.

I like this book very much not only because it is very well-written and thought out, but also for its up-to-date and broad coverage. It covers Version 2 of the Web Ontology Language used for Information Modeling, so new features such as property chains, keys, and custom data types are discussed. It has a good tutorial on SPARQL, and the chapter on Patterns and Best Practices include architectural recommendations and useful tips for managing URIs and annotations.It provides references to important concept papers, and to popular open-source and commercial tools.

I do hope that future editions of this book will include: more concrete discussions of the challenges involved in modeling and using Semantic Web data due to the paradigm's adherence to the Open World rather than the Closed World Assumption, and recommendations on potential approaches to model versioning and addressing security concerns such as role-based viewing of Semantic Web data.Overall, however, an excellent book! ... Read more

Product Description
Explains the core principles of Extreme Programming and details each step of the development cycle. Teaches readers how to work with an on-site customer, define requirements with user stories, estimate the time and cost of each story, and perform constant integration and frequent iterations. Softcover. DLC: Computer software--Development. ... Read more

Customer Reviews (31)

XP installed is both interesting and thought provoking
Whether you believe XP can work or not, this book will cause you to think about software programming in ways you never had before.By now most of us are familiar with the basics of XP: simplicity, communication, feedback, and courage. At the core of the XP philosophy are the concepts of pair programming, writing unit tests before coding, and small incremental software releases.The emphasis is on quality and rapid turn around.

The book opens with a foreword by Kent Beck.He is the creator of XP, and the author of Extreme Programming Explained. "XP was conceived and developed to address the specific needs of software development conducted by small teams in the face of vague and changing requirements."What this book does is to take it one step further by showing us how to implement the controversial principles of XP.The process begins by defining the roles of the customer, programmer, and manager.Each participant must provide a symmetric piece of the XP pie. The customer: determines what is to be done and how it is tested. The programmer:designs, tests, and builds. The manager: coordinates and facilitates the interactions between customer and programmer.

The authors tell us that software analysis is done in stories. A story is a short description of how the system will behave. The requirements gathering phase consists of the customer telling a story of what the software is do. Written on 5x8 index cards these stories will be later refined, sorted by importance, and handed to the programming teams for implementation. "Stories should encompass a week or two of programmer time."Any more than a week and the story is too long, any less and the story should be combined with other stories and treated as a group.When the stories are done it is time to write the test code.Working on one story at a time the programmer writes a test for each task in a story, and then codes for that particular task until it works.

After reading this book, readers will be amazed at the simplicity of the XP system.Metrics and modeling is not really necessary in the XP world."Success is measured in Resources, Scope, Quality, and Time." The book was written in the clear and lighthearted manner we've come to expect from the XP family. You may not be ready to embrace the change, but XP installed is both interesting and thought provoking.

Good solid content, but not the best book to start with
This book is part of a series with "Extreme Programming Explained" and "Planning Extreme Programming", and needs to be viewed in that context. "Extreme Programming Explained" is the manifesto, designed to get you fired up about the subject but thin on detail. "Extreme Programming Installed" covers some of the same ground, but focuses on real-world examples and advice on how to make Extreme Programming really work.

Jeffries and the team are not afraid to face up to things people have trouble with in real situations. The book covers dealing with difficult managers and customers, deciding what needs testing, making pair programming work for you, and lots more. The bulk of the book goes through the practices of Extreme Programming step by step, but some of the most useful stuff is contained in the so-called "bonus tracks" which appear at the end. The book also has a large and interesting annotated bibliography. Well worth reading, but I'd recommend that you start with "Extreme Programming Explained", then read this one if you like the idea, but want a more practical approach.

One book, many authors
There's a certain amount of repetition in this book.It makes me feel that perhaps each of the three authors took their assigned chapters and wrote them, much like they would take their assigned "story cards" at the beginning of a project.
But there's good practical advice here.
Take out a yellow highlighter and resolve: "OK, I'm going to highlight at least one good idea on every page".You'll be able to do it.

If you read only one book on XP, this should be it.
I've read several of the original XP books (Explained & Planning) and to me this is the one that best explains XP and how to implement it.This book was a revolution for me, and I haven't looked at software development in the same way since I read it.It's hard to convert a company (especially managers) to XP, even at a new company on a new project.Managers typically want developers to agree to schedules based on business goals.XP will show you how to do this, but XP won't let you do the impossible.There are tradeoffs, functionality for time.Less time equals less functionality.Sometimes managers just don't understand this (they want it all and they want it now).In that case, it's best to find a new job!But if you are able to apply the XP method, you will love your work, your customer and manager will be happy, and software development will be a pleasant and enjoyable experience.

A final note, I've read this book twice and several sections probably over a dozen times.It can be a little skimpy on details and examples in a few places.I've recently glanced through the new XP books and they give examples and fill in details, but they're expensive and you'd have to spend hundreds of dollars to buy them all and get all the details!Instead look to the web.There's an XP newsgroup (search for it with Google).This book won't take you 100% but it will get you close enough to make it the rest of the way.And of course if you can afford to buy XP Explained and Planning XP I think they're worth it.

Accurate, Practical
This book, as well as "Extreme Programming Applied" by Ken Auer and Roy Miller are the two which should be read by a developer after the introductory "Extreme Programming Explained" by Kent Beck. XP Explained will encourage a reader to the new way of thinking, without bothering with technical details. For a manager it is OK, but for the developer, a bunch of questions will arise. "XP Applied" and "XP Installed" are to answer these questions, providing lots of tips, tricks and case studies.

The only disadvantage is that all the useful examples in these book contain code in SmallTalk, while C++ and Java are popular nowadays. SmallTalk has a distinct, unique style and may frighten C++ or Java developers. That's why I've rated the book four stars.

I would recommend this book to any XP'er. ... Read more

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
The changes to UNIX programming that have taken place since 1985 are extensive to say the least. The first edition of Advanced UNIX Programming is still used and considered to be a must have book on any UNIX programmer's shelf. With this new edition UNIX programmers now have a one-volume, comprehensive, in-depth guide to the essential system-level services provided to them by the UNIX family of operating systems - now including Linux, FreeBSD, and the Mac OS X kernel (Darwin). All UNIX application programs, regardless of what language they are written in, run on top of these services, so mastering them is essential for successful UNIX programming. And, with a movement towards open-source systems, programmers will appreciate the book's emphasis on portability. ... Read more

Customer Reviews (19)

Read more on Unix
The copy I read had a different cover.
This book is interesting, showing you the relation between C and Unix.

THE book to get for UNIX programming
I am a systems administrator professionally, but I have a need to know the inner workings of UNIX that only seems to be covered in programming books. Specifically relating to certain system calls and interprocess communication methods.

This author has forgotten more about UNIX than I will ever grasp. While this book is dedicated to programming applications in UNIX and understanding the operating system's function calls, I am finding it to be a very handy reference for advanced system administration as well. The book is worth the price just for the chapters on process communication, in my opinion.

I really like the author's writing style. He gets down to business and covers the material without adding a lot of needless fluff or by making the chapters overly wordy.

The book is designed to server as a reference and is well-indexed, which is refreshing to find these days. It's very easy to find a topic you need as not everyone will need the amount of depth covered by each chapter in full.

I wish there were more UNIX books out there like this one.

Informative
The book is good for beginners.All you need to know to get started with Unix/Linux programming.

A very useful reference
I bought this book in order to get an overview on what primitives I have available on a unix system for doing system programming. I found the book to be very useful for that purpose.

I use it occasionally.

I also found my peers lending it from me again and again.

To summarize: useful.

The best UNIX programming book that I know of
What's more to say, the title say's it all...Buy it! ... Read more

Product Description
Need help understanding the SAS macro facility? You will find all the answers that you need in this easy-to-follow book! Michele Burlew puts her decades of macro programming experience to work for you as she guides you through the basics, as well as the more complex features of the SAS macro facility. Updated extensively for SAS 9, this book includes plenty of examples and step-by-step instructions. You will learn the elements of the macro facility (macro variables, macro programs, macro language), how to write a macro program, macro programming techniques, tips on using the macro facility, how the macro facility fits into SAS, and about the interfaces between the macro facility and other components of SAS.

New topics for the second edition include using SAS 9 macro and SAS language features, debugging macro programs, adding error checking to macro programs, and building a library of utility macro programs.

Beginning macro programmers will learn to write SAS macro programs quickly and efficiently. More experienced macro programmers will find this book useful to refresh their conceptual knowledge and expand on their macro programming skills. It is also important to note that the macro facility is a highly popular part of SAS and found in the job requirements for many SAS programming jobs. In addition, macro facility concepts are tested on the SAS Advanced Programming Exam. The book assumes some SAS programming experience, including knowledge of how to write a DATA step and how to use SAS procedures. ... Read more

Customer Reviews (7)

Good, but not helpful!!
I bought 'SAS Macro Programming Made Easy' for two reasons: (A) I wanted to learn Macro programming in SAS and (B) I wanted the process to be easy!Via the book, I understood (not learnt) how Macros in SAS should work.But, the book does not offer any practice sets; so, one never gets the feeling that one has learnt much.It is primarily all theory (which is good), but sans practice (a bummer!).For the amount of money charged, the book should have offered some practice sets.

I love all the examples in this book
Each and every statement's syntax is followed by at least one example and its execution log, in which the readers are shown the resolution of macro variables used in the sample code. I find that wonderful in helping me understand the "mechanism" of macro execution.

Definitely recommended for newbies.

easy read and easy use
it's very easy to find information you want, and very handy. recommended.

Good introductory book to learn macros
This is a well organized book that gently introduces macro programming. If you have some knowledge of macros then you could learn and move quickly through this book (probably to Carpenter's Complete Guide to the SAS Macro Language.

Though, the depth of material and examples in this book are limited compared to Carpenter's, it much more readable and accessible.

Good
Through careful and patient reading, this book helped me learn Macros.The style of explanation is a little like a recipe bookand this style made the reading for me dry.For many readers, however, the book should be very useful, for it has info not easily found elsewhere. ... Read more