Follow Slashdot stories on Twitter


Forgot your password?
Linux Books Media Software Book Reviews

Review:Beginning Linux Programming 67

Kurt Gray sent a review of Beginning Linux Programming, by Neil Matthew & Richard Stones. Click here to learn how to contribute more code.
Beginning Linux Programming
author Neil Matthew & Richard Stones
pages 710
publisher Wrox Press
rating 8/10
reviewer Kurt Gray
summary A fair time worthy of your UNIX programming virginity.

Hark Ye Newbies, the Clue Phone Ringeth!

The trees felled to print this book died for a worthy cause: to entice more programmers to hang out at Camp Linux, especially newbie programmers. Our two friendly co-authors, their three editors, and a small army of technical reviewers and other hangers-on, will gently take your quivering little hand and whisk you away into the enchanted forests of shell programming, curses, terminals, file I/O, pipes, sockets, shared memory, DBM files, Tcl, Tk, HTML, CGI, gdb debugging, and some other crazy places that would scare your Mom if she ever found out. The descriptions of each topic are clear and almost every page includes a tasty morsel of sample code, constantly assuring that reader that even drooling idiots like you can write real-world UNIX applications in short time.

Dropping the "L" Word:

Fortunately the content is not biased toward any particular distribution of Linux, but in fact it's not particularly biased toward Linux either. I am hard-pressed to find any part of the book that can not be applied to UNIX in general, so I think a more appropriate title for this book would be "Beginning UNIX Programming", but I suppose the drawbacks of doing so would mean 1) whining tech journalists would complain of the lack of Linux programming books because they didn't bother searching under "UNIX programming", and 2) Linux is a flavor of UNIX anyway so you may well teach newbie programmers the UNIX way of doing things.


What I'm reading here is the actually the third printing of this book, circa 1997, (first printing in 1996) and many things have happened in Linux development since then so unfortunately there's no mention of GIMP, GNOME, Gtk, KDE, Qt, MySQL, Mesa, WindowMaker, and other areas that currently hold the interest of so many Linux hackers. And true, perhaps these topics too advanced for a book called "Beginning Linux Programming" but the book does attempt to touch upon all aspects of Linux programming so why not say a little bit about the APIs that are hosting the coolest parties.

What's Good:

  • Very comprehensive. It would be hard to read this book and still be confused about UNIX architecture.
  • Clear examples. Unlike so many programming books where the example code spools on and on for pages, the examples in this book are divided into easily digestible bite sized code snippets, separated by block of text to explain what's going on every step of the way.
  • Quick guides to common tools: This book explains the simple yet non obvious commands every UNIX programmer has become familiar with: gcc, make (and Makefiles), gdb, patch, diff, tar, cflow, cxref, indent, lclint, etc. It takes care of most of the questions you'll find posted in comp.os.unix.programming newsgroups.
  • Bonuses: It seems to me the authors did not have to discuss topics such as using DBM databases, HTML authoring, and CGI programming in this book, but they do so anyway which makes it all the more harder to keep this book out of arm's reach.

What's Bad:

  • PERL, anyone? There's a whole chapter devoted to Tcl and yet only 2 pages devoted to a little something, maybe you've heard of this thing, called "perl"?!
  • Open Source, anyone? Fails to reiterate the most valuable asset of Linux which pertains to programmers: it's (almost) entirely Open Source. The code is all there right under your nose! Feel free to browse through it and tell the developers what you think. And sure you could spend many weeks writing your own special application but chances are someone out there has already started an Open Source project to develop exactly what you need. That's what set's Linux apart from so many other flavors of UNIX is the prevailing code license: "GNU's not UNIX!".
  • A little bit dated: Since its current printing is from 1997, there's no mention of the newer APIs common in Linux these days (GNOME, KDE, etc. etc.).
  • Guilty of declaring fixed-size string buffers: Most of the C code examples reinforce bad habits such as feeding external data directly into fixed-length character buffers. Some examples should have titled "How to Make A Core Dump File". I don't think you can say enough to persuade C programmers to consider the stability and security of their applications. You may accuse me of nit-picking here, but I thinks its best to teach programmers while they're young so to save them a major rewrite later on.


It's a keeper. I think even the seasoned UNIX programmer would find it useful due to the variety of topics covered therein. Handy for answering the simple questions like "How I read/write to a DBM file again?" This copy is staying in my office bookshelf.

Pick this book up at Amazon.

Table of Contents:

Chapter 1: Getting Started

What is UNIX? What is Linux? GNU, Free Software Foundation, The C Compiler, C header files and libraries, UNIX philosophy

Chapter 2: Shell Programming

What is a shell? Pipes and redirection, shell as a programming language, shell syntax, example app: audio CD collection cataloger

Chapter 3: Working with Files

UNIX file structure, System Calls and Device Drivers, Library Functions, Low-level file access, Standard I/O library (in C), File and Directory Maintenance, Scanning Directories, Errors, Advanced Topics (file descriptors and memory mapped I/O)

Chapter 4: The UNIX Environment

Program arguments, Environment variables, Time and Date, Temp files, Host information, Logging, Resources and Limits

Chapter 5: Terminals

Reading and writing to the terminal, the terminal driver and interface, the termios structure, terminal output, identifying the terminal type, detecting keystrokes

Chapter 6: Curses

Compiling with curses, Basic curses features, keyboard input, multiple curses windows, subwindows, the keypad, color, example app: The CD audio collection using a curses interface

Chapter 7: Data Management

Managing memory, memory allocation, the NULL pointer, lock files, deadlocks, databases (dbm), Example app: The audio CD catalog using dbm

Chapter 8: Development Tools

The make command and Makefiles, Source code control (RCS, SCSS), writing man pages, making patches and tar files

Chapter 9: Debugging (C code)

Types of errors, code inspection, using gdb, more debugging tools (ctags, cxref, cflow, prof, gprof, lint) Assertions, Memory Debugging (ElectricFence, purify, Checker)

Chapter 10: Processes and Signals

Process structure, viewing processes, system processes, process scheduling, waiting for a process, input and output redirection, threads, signals, signal sets.

Chapter 11: Interprocess Communication: Pipes

Process types, Sending output to popen, the pipe call, parent and child processes, reading closed pipes, pipes used as standard input and output, named pipes: FIFOs, Example: the CD catalog as a client/server application

Chapter 12: Semaphores, Message Queues, and Shared Memory

Semaphores, UNIX semaphore facilities, shared memory, message queues, queue efficiency, IPC status commands

Chapter 13: Sockets

Socket connections, socket addresses, host and network byte ordering, Network information, the Internet daemon, socket options, Multiple clients, the select() function

Chapter 14: Tcl: Tool Command Language

"Hello World" in Tcl, Tcl commands, calculations, substitutions, error handling, arrays, lists, procedures, Input/Output, Tcl extensions, expect, [incr Tcl], TclX, networking, graphics, Tk, tgdb

Chapter 15: Programing for X

X server, X protocol, Xlib, X clients, X toolkits, X Window Manager, the X programming model, the Tk Toolkit, windows programming, configuration files, Tk widgets, geometry management, inter-application communication, Example app: a bitmap display program in Tk, Java, X programming with Java

Chapter 16: Programming for the Internet: HTML

What is the World Wide Web, writing HTML, HTML tags, HTML tables, HTML hyperlinks, serving HTML pages (Apache), Server-side Includes

Chapter 17: Internet Programming 2: CGI

the FORM tag, the INPUT tag, WWW encoding, Writing a server-side CGIprogram, decoding form data, using perl as a back end to the CGI, returning HTML to the client, Tips and Tricks, Example app: the CD catalog online written as a CGIapp in C

Appendix A: Portability

Language portability, reserved names, hardware portability, sizes, byte order, char, union packing, structure alignment, pointer sizes, moving to C++

Appendix B: FSF and the GNUProject

The GNUproject and GNUPublic License

Appendix C: Internet Resources

Newsgroups, WWW locations, FTP archives, CD vendors, Linux specific

Appendix D: Bibliography

Standards, other documentation, other cool books not related to computers.


Picture of Tux

Survey Card

Back Cover

Top Surface of My Desk

My Feet

The Carpet

Foundation of this Building







This discussion has been archived. No new comments can be posted.

Review:Beginning Linux Programming

Comments Filter:
  • Even better, go to AddALL [], and search for lowest price. It's like PriceWatch [] for books.
  • It's been several months since I read the book, but I don't remember it making any (or much) use of linux.h at all.

    It also clearly explained the different symantics of the select() call between Linux and other UNIXes. That emphasized portability nicely IMHO.
  • Other comments...

    1. Some things are a bit out of place in a book like this - HTML and CGI for one thing. There are ZILLIONS of books on those, and with PHP or mod_perl, CGI is pretty much irrelevant anyway.

    2. It's good about emphasizing differences between Linux and other UNIXes. There aren't many, but it did mention some, as in the select() call. Valuable stuff.

    3. Its examples are great when you want to get some code quickly cranked out. You can cut and paste a lot of it into your own programs.

    Overall, this and _The C++ Programming Language_ are probably the two best non-O'Reilly computer books.
  • One of the first things I did after I got comfortable with C programming was to write a set of functions that would malloc() space for strings on the fly... I still use those functions in almost everything I write; they're probably the oldest code of mine that's still in use...
  • int ci_getstr(char **buffer)
    int length = 0;
    char ch;
    if (*buffer)
    free (*buffer);
    (*buffer) = (char *) malloc (1);
    (*buffer) = (char *) malloc (1);
    ch = getchar();
    if ( ch != '\n')
    if (ch == '\b')
    if (length)
    printf ("\b \b");
    if ( ( *buffer = (char *) realloc (*buffer, length) ) || (!length) );
    return 0;
    printf ("\a");
    if (*buffer = (char *) realloc (*buffer, length+1) )
    (*buffer) [length] = ch;
    printf ("%c", ch);
    return 0;
    } while (ch != '\n');
    if (*buffer = (char *) realloc (*buffer, length+1) )
    (*buffer) [length] = '\0';
    return 0;
    return 1;

    /* This one is designed to work with the tty echo turned off... if you have echo turned on, take out the printf()s. For reading passwords and stuff, take out the printf()s _and_ turn off tty echo. */
  • ...and has a copy of the license (for what seems
    to be legal reasons) but throughout the book
    there's no words to encourage readers to get into
    Open Source projects and how they can contribute
    and reap benefits of Open Source. The Acknowledgements
    includes thanks to FSF and GNU but in a sort of
    tone as thanking Santa Claus for all the free
    stuff -- we don't want new Linux programmers
    thinking that GNU developers live in some far off
    monastery where they write tools all day for to
    atone for their sins in past lives -- GNU is not
    just about generousity, it's really about "We're
    building Linux because we want it and need it so
    if you like it too then why not contribute some
    of your code too".
  • I've read most of this book, but gave up and decided to read "Advanced Programming in the Unix Environment".

    I didn't like "Beginning Linux Programming" for one main reason. It tries to cover way too much in too small of a space. It covers everything from shell scripting to X11 programming(but tells you it's a waste of time and you should use a toolkit) to Tcl/Tk. It covers just about everything, but covers nothing well.

    I would suggest you save up and buy a bunch of smaller books from O'Reilly than buying this one. At least you'll get some information that you can use.

    Save your money.
  • VERY good book. It's sitting under my mouse right now at home. :-)

    Honestly, this book gives you the skinny on how to program for a unix-style environment. It does NOT cover X, Tcl/Tk, shell or perl. It covers C and how to use the library functions given in an ANSI/Unix environment to a very high level of usefullnes.. Shared memory, semaphores, devices...

    It's as good as Programming Linux Kernel Modues book, published by ORA. That one's beside my bed, although it hasn't been openned in quite some time now.
  • I haven't seen this book, but it looks like it probably doesn't do a very good job of teaching C, though it probably doesn't require any previous knowledge. I would strongly suggest that if you're going to do any C programming, get Kernighan and Ritchie's _The C Programming Language_ (Prentice Hall). It is useful both for learning the language (it's in a textbook-ish format and has problems), and is also very useful as a reference.
  • Order []Here is that link at and the price including fedex 2 day is only $30. Thanks for the link!
  • I ordered a from bookpool half an hour before you posted and got a confirmation its in the mail. Woohoo! It must be too late now as either bookpool has been slashdotted or doesn't have the stock like amazon!
  • Yep, asking too much. Or rather giving up too much. There are some absolutely wonderful C programming books, but they don't cover GTK. Uneqiuvocally, I recommend O'Reilly's "Practical C Programming" It's not platform-specific, but takes a very unixy approach. It is a potentially difficult book, tackling some algorithms and data structures, including pointers and memory management. These might be drawbacks to the neophyte programmer, but are definitely a plus if you come in with some experience.
  • I didn't like "Beginning Linux Programming" for pretty much the same reasons.

    A much better book is "Linux Application Development" by M.K. Johnson and E.W. Troan.
  • by Waldo ( 4398 )
    Stevens is the man. If I could only read one programming book, APUE would be the one.
  • >> No type system to speak
    Ho, ho, ho, seen Perl 5 ?
    More of a type system than SmallTalk.

    >> Non-orthoganal syntax
    err.. ?? Designed by a linguist to have a natural syntax rather then theoretically perfect but pain to use languages (Pascal, Oberon, ML, etc.) maybe, but that's a plus point for Perl.

    >> behaviour isn't well defined
    As in what behaviour ?
    Seems as well defined as any other cross platform language to me, if not better (Perl is often more portable than Java IMHO).

    >> one cannot write correct programs that use stdio thanks to the lack of an _exit().
    Say what ?
    A million CGI programmers have no problem with stdio.
    And if you need _exit(), how about
    use POSIX "_exit";

    >> Where should I stop?
    Perl has its flaws, as does every engineering compromise, but these aren't it...

    And remember, this was in comparison to TCL.

  • Just about any book out of that publisher is good. Forget Sams or Que, these books are some of the best money can buy. I picked this particular title up a little over three weeks ago and have used it a few times since then. As the review above said, it does indeed cover a lot of material and does so coherently and in an easy to digest manner. Highly recommended to the beginner and the seasoned professional just looking for a good reference on most major linux programming areas. If tied together with a good programming theory book the pair would be ideal for beginning to intermediate computer science courses.

    As far as this book over looking Perl, it was probably a choice, not an oversight. There are already several books out there on Perl and many more books that touch on it in relation to other topics. There wasn't a good general "catch all" title out there though... they filled that void. Sure they could have thrown it in, but I don't think that it takes that much away from the value of the book.
  • This book is like man pages; it refreshes more than teaches. I find it indispensable when I have to use, say, semaphores and shared memory, and haven't used them for a year or so. Instant memory awakener. You better know C first, and have some concept of multiple processes communicating together (race condistions, deadlocks, etc).

    I will certainly buy the next edition, but it had better continue the style and content. Add new chapters, but don't take away the old.

  • Two totally unrelated points/opinions:

    First, I would strongly suggest you avoid SAMS books. Like the plague. Sometimes (in the past, and never to be repeated if I can help it) I would buy SAMS books on subjects about which I know a thing or two. In literally every case I've found these books to be full of gross errors. And this doesn't address the shoddy editing that fairly permeates them. Avoid SAMS. Buy O'Reilly (unabashed and uncompensated endorsement -- and no, I don't work for them)!

    Secondly, I'd say you ought to skip O'Reilly's bash book if you're learning shell programming. This one title is the most disappointing O'Reilly book I own. It was none too clear, and contained very little in the way of practical examples. It's somewhat useful as a general introduction to using bash, but I don't think it's all that hot at teaching shell programming. IMO Beginning Linux Programming is much better at introducing that -- even though it has just one chapter on the subject. Hopefully O'Reilly will improve their bash book, though.

  • Not that I have anything against Amazon, but I would recommend using They are only a technical book reseller, and they have better prices than amazon. As far as I can tell, has the best prices for its books on the web. Just a suggestion.
  • by DeathB ( 10047 )
    Where's the link for "here"
  • Use
    fgets( string, n, stdin ) for input
    snprintf( string, n, format, params ... ) for creating strings
    strncpy( str1, str2, n ) to copy
    These routines restrict the number of characters that they deal with to n, thus preventing buffer overflow exploits that write pernicious values to the stack and cause your functions to return from whence they did not come.

    Also a good habit to
    str = (char*)malloc( strlen( s ) + 1 );
    instead of just allocating a really big array or something.

  • If you know ASM you shouldn't have problems with C. C is just ASM with some syntactic sugar ;)
  • "The UNIX Programming Environment" by Kernighan and Pike (dated perhaps in some respects but still worthwhile)
    "UNIX Systems Programming for SVR4" by David Curry (C only, Sys-V focus)
  • I'm looking for some book (perhaps this is it, but I don't know) to learn to write linux programs. I have a slightly odd background, I started (like may of my misguided friends) on QuickBasic, then jumped straight into Assembly language, never really learing c that well.
    I guess my ideal book would be one that taught c programming, but also integrated it with GTK for the beginner.
    Asking too much? :)


    -The true rebel will ignore the Preview button and go straight for Submit
  • I bought this book about a year ago, and it was one of the best purchases I made. It's a great step-up to Linux type book - I could already program in C, and had a working knowledge of shell and stuff, but had never done any real *ix programming before; this book was a real boon in learning how to do it.

    Admittedly a few of the examples are a bit contrived, and some of the networking section isn't wonderfully explained, but as a quick stepup for people coming from other platforms to Unix, its great...

  • Switch to C++ and use String class. Problem solved
  • The biggest problem I see with this book is that there is no mention of writing portable code. Linux programs, in particular, lack in this area. #include <linux.h> just doesn't cut it when it comes to trying to run software across multiple platforms.
  • How to properly allocate string space? Well, malloc() works..

    You mean though, how to allocate enough space that you don't get overflows.

    Can't be done. Any buffer you can allocate can be overflowed if someone tries hard enough.

    What you need to do is allocate a certain buffer, n bytes for instance, and read only n-1 bytes from the input. Use an fgets() call to read a certain number of bytes, or if you're reading one byte at a time, simply keep track of how many you've read and when it gets to n-1, write a zero to terminate it and exit.

    Being that ram is 'cheap', I usually allocate 4k buffers at a minimum, even for command lines and other 'small' strings. Then I use a strncpy or fgets to read data into the string. Both of these functions have the benefit of reading a certain maximum number of bytes and then terminating, regardless of hitting the end of the string.

    I can't see many reasons to make strings dynamic for the most part. Simply allocate as much space as you're going to need in the worst case. (Unless that worse case is a megabyte-long string...)

  • When i first installed linux (ah, what memories) i remember being overwhelmed (in a good way). Here I had many many packages -- most of which i did not understand and many i did not use for a year or more. The title says it all _Beginning Linux Programming_ -- if you are a newbie, this book is a great asset.

    A year ago I bought this book and within a month found it to be worth the price. I still have not found any reference that so clearly and succintly describes the curses/ncurses library. The philosophy of "a little bit of everything" is great -- if you want to learn more perl or tcl or... pick up an ORA book. but this book lets new users (and older users like me) know enough to find out more.

    yeah, the typical slashdotter learned all this stuff long ago. and if you develop under unix, this is old hat. but for the windows users who switch over to linux, this is required reading.
  • Excellent. I had a Barnes and Noble web coupon for $10 off any purchase over $25 one day last week, I happened to see this and ordered it. It came yesterday, haven't cracked it open yet. Glad to hear this was a good choice. I think it cost me like $19 total. :-)

  • Sorry if this is a little off topic but here goes:

    Most of the C code examples reinforce bad habits such as feeding external data directly into fixed-length character buffers...I thinks its best to teach programmers while they're young so to save them a major rewrite later on.

    I haven't done C programming in a while so I don't remember how to do proper string manipulation. However my g/f is going to take a C class this fall so I need to get up to speed so that I can help her. What would be the correct way to allocate a string in order to allow external input, say from the keyboard? Anybody care to debate fixed size vs. dynamic size strings in C?

  • >>No type system to speak of
    >Types are inferred from their context. treat a scalar like a number and so will perl. the 21st
    >century is calling - time to hang up your lisp/ml puritinism - those languages were never any good
    >for GETTING WORK DONE NOW. I emphasize that because perl lets you get things done much quicker
    >than anything else.

    There was a reason for types and that was you'd rather the compiler picked up your bugs, than have to try and work out what went wrong at run time (when your code is treating your string as an integer, or vica versa).

    Perl's good for a quick hack, where you're not going to keep the code. But try and maintain it...oh boy.

  • I was just looking at Linux programming books over at Amazon and came across this. I was amazed at the reader reviews, where it received a 5 star average! Only a few 4 stars, tons of 5 stars! Then I head to Slashdot, and right at the top of the page, Beginning Linux Programming is staring at me. Is this an omen?
  • Pretty cool. I checked out 4 random books at both and (Developing Linux Applications, Linux Application Development, Linux Device Drivers, LINUX Kernel Internals). The lot, including ground shipping, costs $133 on Amazon vs. $113 on Bookpool. Only problem I see offhand is availability--Linux Device Drivers is out of stock at Bookpool. :(
  • Appendix A is "Portability".Mentions different sizes of int and others on different systems, byte order, etc.
  • Remember that strncpy() does NOT guarantee a null-terminated string.
    It adds the final '\0' only if the source string is shorter than the length parameter.
    strncpy(buf, input, sizeof(buf)); should always be followed by
    buf[sizeof(buf)-1] = '\0';

    Or use strlcpy() if your OS has it (OpenBSD) and you don't need ANSI conformance.
  • I'm not exactly a "beginning" Linux programmer -- I've been writing C code and scripts under Linux for 4 years now. However, this sounds like a book I need anyway. There are numerous topics I have not yet delved into where I would like a quick introduction instead of a dedicated (expensive) topic-specific reference. I think I'll buy it... thanks for the comment.
  • Beginning Linux Programming
    by Neil Matthew, Richard Stones

    List Price: $39.99
    Our Price: $31.99
    You Save: $8.00 (20%)

    Paperback - 1000 pages 2 edition (September 1999)
    Wrox Press; ISBN: 1861002971
    This item will be published in September 1999. You may order it now and we will ship it to you when it arrives.

  • Yes, I know there's no Perl chapter in this one,
    although there will be at least one chapter on
    Perl in the next edition. I know, I've just
    finished writing it. :)
  • Yes!

    You wouldn't believe how many "professional" programmers don't do this. Truncatation is OK (via strncpy) -- not great, but OK. Writing beyond the end of your allocated memory is just horrible. Where I work, we just had several nasty bugs because of things like this:

    char buf[16];
    strpcy(buf, getenv("SOME_VAR")); // aaaaaaah!

    Should be:
    char buf[16];
    strncpy(buf, gentenv("SOME_VAR"), sizeof(buf)-1);

    Of course, if you're using C++, you can avoid the whole issue by using the string class, which holds variable length strings:

    string s = getenv("SOME_VAR");

  • For me, this was probably the best programming book I've ever read. But whether it's good for you or not depends largely on how you like to learn.

    >It tries to cover way too much in too small of a space.
    This is exactly why I loved it. It explained a huge number of points clearly and concisely, gave a brief code example, and then moved on without making me wade through another hundred pages on a topic I already knew all I wanted to know about. It's an ideal book for someone who likes to grab a book, read it cover to cover to cram a bumch of concepts in their head, have a reference in which it's easy to find exactly the piece of information that they're looking for, and then when they try it themself and it doesn't quite work, they're happy to bring up the man pages to get the rest of the details.

    But if you want to have all of the details in the book, if you want a comprehensive treatment of each topic, if you don't need a book to enlighten you about what's possible, but prefer a book where you can look up exactly how to do everything that's possible, then perhaps this isn't what you're looking for.
  • I haven't seen any books similar to this. I only see UNIX/Linux "user" books (installation process, basic utilities, etc) and advanced programming tomes (A-W's excellent "Programming in the UNIX Environment").

    I think that this may be the only good "beginning" UNIX programming book out there... if there are others, please tell me what they are!

    BTW, I agree with the "this is not a Linux book" comments -- it really is a general UNIX book relabeled to sell better. Which is good, since I'm rather partial to FreeBSD myself :}

  • I just bought the book, and now I plan on sending the book back. My guess was last year, the title was "Beginning Unix Programming". I was okay until there was a single paragraph on threading, and it said and I quote "At present, UNIX support for thread-based execution paradigm is limited. The POSIX.4 spec defines a thread mechanism useful for real-time applications of UNIX and implementations are finding their way into UNIX-derived systems, including Linux. (This part kills me!) Due to their relatively poor support at present, we won't cover them further here."
    First, count how many times UNIX is used, and second threading in Linux has "relatively poor support"!!!
  • heh only if it happened at 11:11
  • Whenever you plan to buy a book online, it's a good choice to check on [] because they do a price compairison between 25 book sites (including shipping). The best feature I found was on the front page there's a listing of daily hot deals from the book stores. For example, here's the book being discussed [] and when you subtract the $10 discount on a purchase over $10 from BUY.COM, the final price (with shipping) is $21.66. Not a bad deal.

    - Jeff
  • It seems that only barnes and noble has a notification service for new books. I am having a problem getting the 'notify me when new books happen matching my search criteria' option to work. Can someone enlighten me on this? Or suggest another option so that I don't forget to buy the next edition of this?
  • According to barnes and noble (, the second edition is comming out on September 20th of this year. Hopefully they will update it to include coverage of the current APIs.

To avoid criticism, do nothing, say nothing, be nothing. -- Elbert Hubbard