Customer Reviews

Developing Linux Applications

5 star:		(5)
4 star:		(4)
3 star:		(4)
2 star:		(2)
1 star:		(5)

 

 

There are a number of factors that separate good toolkit programmer manuals from less gifted ones:

* There should be a number of rather large realistic examples - not just dozens of snippets rivaling the "Hello, World's" complexity. In this sense, Harlow's book is fine: there are good examples of real-life programs that could get the programmer going.

* There should be no cheesy stripped down (and ultimately useless) API reference, occupying the last third of a book. This book doesn't make this mistake either.

* API calls described must be presented clearly, with all parameters documented and return values explained. And that's where this book screws it up real bad.

Let me make it clear - it will be almost impossible for you to try any of the smaller examples from the book without having access to the API reference (or another book for that matter). I mean, having an example like:

htable = g_hash_table_new(HashValueKey, HashValueComparator);

how am I supposed to figure out what the type of htable is? And most examples in the book are just like that. This is a serious problem with the book that should've been caught by the editor or by anyone trying to look at the text with a fresh set of eyes.
And it is a pity - this book doesn't violate the two main principles stated above so it could've been the best one on the subject.

I looked at this book in the bookstore, was impressed by the quality of presentation, brought it home and was writing working applications in a few hours without any other documentation. If you need to get up to speed, I don't think you could do better than this; it's extremely well written and tells its story well.

It has a large sampling of examples, and I really liked them because they were useful in their own right, and tied into the things I wanted to use GTK for.

There are two significant flaws in this book. First, there were a number of embarassing errors that got past the copyreaders. Some functions had upper case in their names when printed; the actual functions are all lowercase. The gtk-config program takes options beginning with double hyphens, not single hyphens. This kind of sloppiness is annoying, and I'm sure there are many beginners who will stop learning, not realizing they are literally a hyphen away from success.

The second problem is that, once you're through the examples, what you really need is a reference book, and this work completely fails at it. The index is embarassingly incomplete, and many aspects of GTK are explained just well enough to get you started, which can leave you hanging later.

But the rest of the book is so well done that I can ignore those flaws. If you want or need to learn GTK, this is a fantastic introduction that will serve you well.

I have been programming console apps in pure, raw C for over ten years, but never could master GUI programming in Windows or X either. GTK has saved me from a GUI-less life, and Harlow's book was my introduction.

Sure, it's not perfect, but I learned a lot years ago from Herb Schildt's books (remember him?) HIS code was fragile as cut glass... but debugging is good practice, and some of his methods were brilliant. (but sloppy)

Eric Harlow is much better. Many of the errors in the code presented (gpointer *data at the end of a callback declaration, when it should be gpointer data, for instance) may well be typographical in nature. I downloaded the example code and built several of the programs with much less difficulty than many console apps I have ported.

Give the man a break. He was the first into the breach, so to speak. If you need a more advanced book, get Havoc Pennington's "GTK+/Gnome Application Programming" and have at it. I have both, and am still learning a lot from them.

This book just isn't very complete. If someone totally new to gtk were to use this book from which to learn, they'd have problems right off the bat - some _very_ significant typos (like the compiler arguments on p.29) and total lack of documentation in several places (see others' comments). Luckily, I already knew a bit of GTK+ and could work around the errors, although the 'missing' documentation bugs me. Some of Mr. Harlow's code is really weird, too - strange pointer conversion creates a compiler warning (p.53), along with some other examples I don't feel like finding. It is a decent book for my purposes - it's like learning from the source, but with a little more documentation. If you know your way around GUIs and have money to spend, go for it.

Don't listen to the reviews below. If you're just beginning in Linux app development like me, then you'll absolutely LOVE this book. I know I do. I'm making a game project now, after reading this book.

Don't get me wrong, this is a teaching book, not a reference (Linux Application Development is an excellent reference, BTW). Buy this and get in the Linux dev scene!

When I first saw this book, I ordered it immediately. When I flipped through it to see the content, I was very excited. When I finally started reading it, I was extremely disappointed. The book doesn't cover so much of Gtk that I can't use it as a reference. The index is so poor that I can't find what it does cover. There is no explanation of anything, beyond a vague description and then a chunk of source code. I've taken to just reading the source code as a reference instead -- at least that way it's clear what everything does. Functions are mentioned and not all of their parameters are explained! That leaves me wondering what that last NULL meant, and finally digging through the source to find out. Or take the section on creating menus with item factories, where the author describes, in a bulleted list, the eight possible values for the flag parameter, and then proceeds to use a ninth one in the following source code, with no explanation of what it does! The examples in the book aren't exactly useful, because they illustrate one (sometimes non-typical) use. The book as a whole just blows. Add to that a very poor code quality even in the example source (which is about all there is left of the book) and this book is a lot closer to my trash can than my bookshelf.

A reasonable first attempt at documenting the GTK toolkit, hopefully as GTK becomes more popular it will have competition.

My most serious problem with the book is the large amount of examples---just flicking through it seems to show every page with example code. Examples should not be used as a way of documenting an API, they should be used to _carefully_ illistrate selected points. And we don't need whole applications in the main text (they should be in an appendix).

Compare for example the definitive Motif programming books, O'Reilly 6/6A and Doug Young's "Programming and Applications with Xt/Motif", both have much more discussion about the fundimentals of the API, and they didn't pretend to document the lower levels (Xt/X11) like this book does with Glib/GDK.

Will I use it ? Yes. Will it become my defacto GTK document ? No. Do I wish it had more substance ? Yes.

If you are looking for a top-level guide to the most basic GTK+ functions, this might work for you. If you are looking for detailed explanations of components, an understanding of the inner workings of GTK+, or any information on graphics go elsewhere. The author skipped over graphics contexts (GC) completely; given the nature of the library, this amazes me.

OK, This book looked great at first glance, but as many of the other reviewers have said, it was totally worthless as a reference. The stuff on the web, even though sketchy in some places, was miles ahead. I have had to look throught the source code for really tough questions. I hope that O'Reilly gets a book out. I have been tempted to go back to Motif because it has really good reference manuals.

I bought this book last week, have read most of it by now, successfully downloaded and installed a version of GTK+ and GLIB in my RedHat5 LINUX, and have entered, successfully compiled, and run many of the GUI examples already. I just read these reviews below and exclaimed, "Boy! This book is not THAT bad." If you are a salty veteran of UNIX GUI, don't buy it, but I found it very helpful.

Maybe, given the incredible rapid growth of LINUX, in another year a better book will emerge (or perhaps a second edition of this one), but until then I haven't seen a better one. Also, regarding the "use the source comment": That is fine if you are already a Jedi Knight, but if not, this book gives you a few working examples to use as a blaster if no light saber is handy ...