Become a fan of Slashdot on Facebook

 


Forgot your password?
Close
typodupeerror
×
GNOME Books GUI Media Book Reviews

Review: GTK+/Gnome Application Development 65

Posted by Hemos from the new-book's-to-read dept.
Thanks to our own Justin for the review of author Havoc Pennington (excellent name)'s GTK+/Gnome Application Development. Click below to learn more.

GTK+/Gnome Application Development
author Havoc Pennington
pages 492
publisher New Riders: ISBN 0-7357-0078-8
rating 6.5/10
reviewer Justin
ISBN
summary Learn how to develop a GNOME application from scratch using gnome-libs and various GNU development tools. Master the canvas, and expand your knowledge of GTK+/GDK/glib while you're at it.
The book is released under an open license so that the book will have no problems keeping up to date with whatever is current in GNOME. It is browseable on the web at http://developer.gnome.org/doc/GGAD/ and can be checked out from GNOME CVS - it is in the GGAD module.

The book is not just a simple explanation of gnome-libs. Rather, it is a book meant to take you from beginning to end of a full GNOME application. GGAD starts off just where it should, with a ~50 page review of glib and GTK+. These sections were fairly well written, and I was able to understand them well. Keep in mind, however, that they are not for beginning glib/GTK+ hackers. The internals of how the libraries work are sometimes mentioned and I can imagine them being confusing to the first time GTK+ hacker. More advanced hackers can probably skip most of these sections, but even an intermediate GNOME hacker could gain a better understanding of how glib and GTK+ work.

The next sections discuss topics like what non-code files are required for a GNOME application (Makefiles, .desktop files, documentation, pixmaps, etc.) They are useful, and I thought occupied the right amount of space (not too little, not too much :)

Next comes a chapter I probably expected to come a bit later on. "Gnome Application Basics" is a summary of internationalization, popt, and configuration data. Unfortunately, I found the sections on configuration data a bit difficult to understand, and disliked seeing example code using some of C++'s more advanced features. Now we arrive at chapter 6, the chapter I think most GTK+ hackers looking to get into GNOME development will find most interesting. It is a discussion of the GnomeApp widget, GnomeUIInfo structs for menus, status bars, online help, tooltips, etc. Chapter 7 will probably also be useful to the same people. It is a quick (10 page) discussion of the GnomeDialog widget, and discusses several types of widgets. It well-written and very complete. Finally we have arrived at the last section of the book - "Advanced GTK+/Gnome Techniques". It is definitely for the more advanced hackers in the house. Chapters 10 and 11 are a very intensive (read: decently written chapter covering some slightly obscure topics in a lot of depth) overview of the GTK+ object system and a somewhat lengthy how to on the use of GDK (some parts I think may come in hand, some parts are probably pretty obscure). Chapter 11 is a titled "Writing a GtkWidget" and is well-written, but I question its usefulness to anyone but library developers. Unlike other sections, I felt this chapter had far too much actual code embedded within it (at least in the second half).

Next is a chapter I expect many people have been waiting their entire lives for ;) It is the long-awaited GnomeCanvas chapter. It is a ~25 page chapter which explains how to use the GnomeCanvas widget. The next chapter, Writing a GnomeCanvasItem makes a good counterpart, and the two work well together to teach the use of the canvas. It is a complex widget, so it may be hard to understand, however. I was lost at times, but I think this was probably me and not the book.

And that's most of it. The next 140 pages or so are all Appendices, some I found useful and interesting, others I found boring and skippable. However, I really must say that Appendix C, "Frequently Asked Questions", was very good and one of my favorite parts of the book :) The only remaining disappointments I had were the fact that the book was aimed towards very advanced developers (which was probably the major disappointment for me), and that libxml was not covered in at least small detail. I know that not everything can be covered, but XML is becoming central to many parts of GNOME.

Purchase this book at Amazon

  1. Overview
    1. Introduction
    2. glib: Portability and Utility
    3. GTK+ Basics
  2. Building a Gnome Application
    1. Creating Your Source Tree
    2. Gome Application Basics
    3. The Main Window: GnomeApp
    4. User Communication: Dialogs
    5. Gnome Applicatio Checklist
  3. Advanced GTK+/Gnome Techniques
    1. The GTK+ Object and Type System
    2. Gdk Basics
    3. Writing a GtkWidget
    4. GnomeCanvas
    5. Writing a GnomeCanvasItem
  4. Appendices
    1. GTK+/Gnome Object Hierarchy
    2. Table of Header Files
    3. Frequently Asked Questions
    4. Online Resources
    5. Code Listings
    6. Open Publication License Version 1.0
This discussion has been archived. No new comments can be posted.

Review: GTK+/Gnome Application Development More

Review: GTK+/Gnome Application Development

Comments Filter:

  • Re:Not a "gentle introduction" (Score:1)

    by Anonymous Coward
    check out the Gtk+ tutorial from www.gtk.org. you're right this is definetely not for newbies, but soon you're not going to be able to survive without it. good luck hacking gtk+.

  • Little 'info' tip.. (Score:1)

    by Anonymous Coward
    You don't need to know emacs to use it. Look at the top and you will see "Up:", "Next:", "Prev:", etc. Just hit "u" for up, "n" for next, etc. Hitting 'enter' on a link (those things with asteriks beside them) will take you to it. Then you just use (u)p to return. I always thought info was a pain to use.. until I discovered the hot keys. Now it's easy as "man" for me. Oh yeah.. q to quit :-)
  • Other distros would be, if they made as much press. We only post what we can link to-and we only get work with the submissions. As it is, GTK is submitted 6 to 1 over Qt, Red Hat by as much as other distros.
  • It isn't really necessary to learn these - at least, not if you can find an IDE to handle it for you. I'm familiar with KDevelop, the KDE IDE, but I'm sure Gnome has an equivalent - Glade perhaps?

    Anyway, these have a wizard which sets up your project - autoconf, automake etc, as well as .lsm files, README, Changelog, license, and the addition of new files etc pretty much as you'll find in any GNU software. It means you can learn the language rather than how to use Unix as a development system - which can be done later (in my copious free time)

    I thinks its best to relegate make files to being out of sight, out of mind, since their not the most friendly of things to look upon.

    You might want to check out the LDP's Linux Programmers Guide as well.
  • Chapter 11 is a titled "Writing a GtkWidget" and is well-written, but I question its usefulness to anyone but library developers.

    I think encapsulating things into widgets is one of the primary strengths of any toolkit. Even if you are writing an app and not contributing to a library, writing widgets allows you to build a much more flexable program. I actually wish there was more, not less, focus on writing good widgets as well as subclassing and combining existing ones.

    That said, I agree with most of the review. Besides numerous typos (which are undoubtably fixed or to be fixed in the online version) this book is extreamely useful for anyone learning GTK and GNOME programming.

    Thanks Havoc!

  • Amen. Writing your own widgets can make things _so_ much easier, all the while improving your code's structure by forcing a clear demarkation between the UI and the internals.

    Case in point:
    When I started coding my first Gnome application (a port of an editor/viewer for certain game records), I quickly became annoyed by the fact that I had to deal with implementing things like popping up Open, Save and Save As dialogs, as well as prompting for confirmations when exiting without saving, etc.

    Porting as I was from a Doc/View based MFC app, I didn't have existing code to throw at this, even though I did have all the routines to do the actually saving and loading. So I just buckled down and wrote my own widget to take care of this stuff -- give it routines that, given a filename, will save or load, and it will deal with all of the user prompting.

    Having done that, my code is much more modular and easy to maintain, and as an added bonus I have a completely general, reuseable widget. Any time I need to make a single-doc-interface program, I can just pull it out -- and I know it's bug-free, because I've used it so many times before. (As a proof-of-concept when designing the widget, I used it to write a notepad-like editor. Took all of 10 minutes or so.)

    Sure you can always cut and paste code from project to project, but if you really want to reuse code, writing your own widgets is the way to go.

    JRaven
  • So I bought this book a week ago and started thumbing through it and I see an actual printed chapter which takes about the automake / autoconf / configure junk which I've wanted to use for a very long time, but could never find a tutorial that was decent enough to not force me to thumb through man (or worse, info) pages. Yay!
  • As luck would have it, I just recently picked up Developing Linux Applications with GTK+ and GDK (not to be confused with Linux Application Development, which, I believe, does not talk about GTK). I haven't had much time to look at it, so I've only gotten as far as the GDK stuff. My intention was to learn about GTK programming so I could get into some GUI stuff under Linux. (I've been doing command-line things under various Unices for a while.) Is the book i grabbed a good introduction to the topic, or should I get this one, which seems to be (by the title, at least) more focused on what I want to learn, and wave good-bye to some more of my money?


    --Phil (Not that the money stays long in any case...)
  • I have to agree with many of your comments.

    Have an object orientated toolkit is vitally important nowadays. It helps keep code size down whilst still allowing all the fancy doodads that people expect.

    I think people need to get into the habit or writing object orientated designs with GTK+ to maximise the benefits of the toolkit rather than getting stuck in the bad C habit of making every thing a global variable !!! (This mainly relates to people new to coding, but i have seen some *terrible* designs !!!)



    Lets face it, in general C is a damn site easier to get that hang of, and get started with, compared to C++ !!! which is why a lot of people will probably start writing programs in GTK rather than QT (By the way, i think the QT toolkit is a very nice piece of design, i just don't like the license... :)


    Iggy
  • >However C lacks many of the features that are the most useful and >that C++ adds.

    Will you C++ users give it a rest? I swear you people are becoming just as anoying as the Java/ Amiga Arexx users....
  • See the subject line. It lets you view info pages using Lynx-style keybindings; since I got it I actually *like* info documents, since they do have some nice features over, say, HTML, but the standard browser makes it too hard to get to them.

    (as a side note, pinfo can also do manpages very nicely, including turning references into 'links')


    Daniel
  • Here's a question I have yet to see an answer to:

    Does GTK+/GNOME support interface resources like MacOS, Windows, OPENSTEP/GNUstep, etc. do? In other words, can I define most of my interface without writing code that says "place a button here, place another button here, create a toolbar, put this button and this button in the toolbar..."

  • The things you're talking about (new releases of distros, etc.) are better served at freshmeat.net [freshmeat.net].
  • C does not lack polymorphism. When you declare the struct for a "subclass", include the "superclass" as the first element. Since no pointer type checking occurs in C, you can treat pointers to the subclass as pointers to the superclass with impunity. And since you're using function pointers for method calls, and the subclass's "initializer" will set them appropriately when it creates objects of the subclass, polymorphism works perfectly.

    The only thing thing C++ gets you with regards to OOP that doesn't find easy expression in C is multiple inheritence. This can be accomplished in C as well, but it's ugly. If you need it, go with C++. If you don't, C is perfectly adequate for OOP.

    --

  • GTK+ seemed a bit contrived when I tried to learn it. They are using OOP concepts in C.

    What's wrong with that? OOP is very natural for expressing many problems, and is usable in _any_ language that supports the concept of a function pointer.

    Remember, OOP is a design methodology, not a language feature. Some languages add extra syntax to support it, but OOP is a matter of semantics, not syntax. Just because C lacks syntax specific to OOP doesn't mean it isn't capable of supporting OOP. It is.

    --

  • Or maybe I should say, I am currently loving it. So far, with only basic knowledge of C and GTK+ (via a very nice tutorial) I have not seen anything that I really did not understand. But then I am only to chapter 9, so I do have quite a ways to go. Thanks for the great book.
  • This isn't meant to come down on HP, just an observation.

    I don't know if it's because I'm on a weird part of the learning curve or because of deficiencies in the book, but there were a lot of things that I was dying to know about that weren't covered in the book. It would have been nice to have had information organized by conceptual topic in the index as well as by code. E.g. how to create right click popup menus is the conceptual topic, but using gnome_widget_popup_foo is the code topic.

    Also, what I really wanted that the book didn't have was entries in the index for ALL functions that were discussed (or mentioned) in the book, not just the ones that had minisections about them. That way, even if the function was only mentioned, you can still get a feel for what it relates to by checking out the information that surrounds where it was mentioned, if you know what I mean.

    The book as far as an intro to Gnome though was very good. I enjoyed reading it, and I'm damn sure glad that it exists. A book of this type doesn't have to cover everything, (as HP pointed out that it can't) but it does a fairly good job at what it *should* do, which is to allow the reader to get a toe-hold into gnome, to the point where reading the reference documentation will actually be helpful. I found that the book was a success in that respect.
  • ... I still feel that the GTK+ library an Gnome framework needs tyhe O'Reilly treatment. An exhaustive volume on each GTK+ widget and a similar tome on the Gnome GUI libraries.

    As for things like CORBA and XML as used in Gnome, these are probably worthy of a volume each themselves. As Havoc Pennington's book points out, the while Gnome environment is essentially various libraries that will make application development much easier.

    Note that I used the future tense. For those of us with little time to learn from the source of existing apps, good books are a must. Perhaps what we need is an entire Gnome series in the spirit of the O'Reilly X Programming books.

    Anyway, I'm now off to buy the printed copy of this book to show my appreciation that Havoc's publishers allowed him such an amazing license.


    Chris Wareham
  • I spent a week of my holiday learning automake, etc. from the info pages. It was frustrating, but only because I started with the autoconf info pages, and then moved onto the automake stuff after a detour through the m4 pages ...

    Using the Gnome help browser was a major help - I'm not an emacs person, so the standard info reader was very unintuitive for me. For anyone contemplating learning the auto* thing, then I can recommend reading the automake page first. For smaller applications that don't rely on unusual libraries this makes the whole thing painless.

    For adding dependency checks (like looking for the GTK+ libraries), just cut and paste from existing Gnome and GTK+ apps. Only if your using some really of the wall librarues will you have to learn the m4 macro language.


    Chris Wareham
  • The two books I would recommend to accompany this book are:

    Advanced Programming in the Unix Environment
    by (the late and much lamented) W. Richard Stevens

    Unix Systems Programming for SVR4
    by David A. Curry

    The latter is a much underated O'Reilly book, that despite concentrating on one flavor of Unix is very useful for the Linux programmers out there.

    A really introductory book for Linux programming is `Beginning Linux Programming' by the usually iffy Wrox Press. It has a some naff stuff in it, but enough good bits to far outweigh the fluff like CGI and HTML tutorials that these sorts of book insist on having.


    Chris Wareham
  • I learnt GTK+ from the tutorial packaged with GTK+ itself. While it's not exhaustive, it is pretty damned good.
    Chris Wareham
  • Do any other members of the Gnome team at RHAD have books on the way? A complete book on ORBit would be fantastic, as the OMG C binding document seems impossible to find at their site.
    Chris Wareham
  • gtk shouldn't get any more covereage then qt, and redhat shouldn't get anymore then whatever else is out there..

    Yeah, and Mozilla shouldn't get any more coverage than Internet Explorer, and computers shouldn't get any more coverage than bicycles, and half the articles should be posted in French, and...

    Slashdot has always been about what Rob finds interesting. Fortunately, what he finds interesting is interesting to a lot of other people too - hence the huge popularity of Slashdot. This does mean that you have to promote some things above others.

    As for the particular complaints that you make, GTK is getting coverage right now because a book has just been released. That's why this story is under 'Book Reviews'. When the book Programming with Qt was released, there was a review [slashdot.org] of that too. And to many people, Red Hat's 100% free status makes it more 'interesting' than proprietary distributions like SuSE or Caldera.

  • I'd get them both. In his GTK+ intro chapter, Havoc says
    If you've already read the Gtk+ Tutorial from http://www.gtk.org/, or the book
    Developing Linux Applications with Gtk+ and Gdk (also from New Riders), you may be able to skip or just skim this chapter. If you haven't used Gtk+ before, this chapter is going to be very fast; read with care.

  • Not a "gentle introduction" (Score:3)

    by Booker ( 6173 ) on Tuesday September 07, 1999 @12:22AM (#1698380) Homepage
    I got the book from FatBrain last week, and I've been plowing through it. I'm new to Linux development, and I don't have a whole lot of programming experience outside of Linux, either. This book is not an easy read. :-) If you're new to programming, skip it for now. If you're new to GTK/Gnome, I'd at least read the online GTK and Gnome tutorials first, and maybe have the GTK book by Eric Harlow(?), also from New Riders, on hand to cover GTK in a bit more depth.

    Don't get me wrong - it's a great book, chock full of good information. It's also the only book in print at this time which covers Gnome development, as far as I know. But if you're brand new to this whole business, it might be a tough read. I'm very glad to have it, though, because someday I'm gonna understand it all. :-)

    Kudos to Havoc and to New Riders!
  • If you want it covered, submit it, rather than posting offtopic garbage. If you want to winge, go somewhere else.
  • not an emacs person either, so when I wanted to learn autoconf (no automake for the mometn), I found it best to compile the texinfo pages into .dvi and view them under xdvi. it's pretty much the only way to make GNU docs palatable.
  • "Unix Systems Programming for SVR4
    by David A. Curry

    The latter is a much underated O'Reilly book, that despite concentrating on one flavor of Unix is very useful for the Linux programmers out there."

    Agreed. It is one of my favorites. I would recommend it to anyone developing in Linux.
  • Well, it isn't the same. "its cover" is similar to "his clothes" or "her clothes"? As opposed to "the book's cover". You don't say "hi's or he'r clothes".
  • Also, I really liked "Linux Application Development" - this is an excelent book that is very broad yet short and to the point (no stupid story lines about aliens or banks to fill pages). It talks about most of the development tools for Linux (compilers, debugers, libraries, etc) and it covers a lot of the system API. Good book.

  • Havoc spells it out right on page 9. What a disappointment. I would argue that CORBA is more central to where GNOME is going than lib-xml (poster complained about lack of lib-xml earlier), but both are truly important and worth looking into.

    I ordered the book before it came out from Amazon and it's treated me well so far. The book bites off a lot and so the pace is *very* quick. You won't read a bit and be Miguel overnight. It is not the end-all GTK+/GNOME book, but a great introduction for people willing to learn. In just the 2nd Chapter, I've pulled out several advanced/expert C programming books to follow along with the code (and you think C++ can be difficult at times!). I've said it before on /., but the best Christmas (praise Jesus!) present I ever got was 'Expert C Programming - Deep C Secrets' by Perter Van Der Linden. Great book; great humor. You'd think he pays me commision (...and I'll accept it)-- it's just that good.

    So in closing, if you know how to program and are thinking about buying some docs to get going with GNOME and GTK+, you need this book, a GTK reference, and 'Deep C Secrets' wouldn't hurt either.

    Good luck.
  • I agree. I saw the book at borders, and although it is a good book, I need a little more information, when I code, and although I do have the source, that is an exhaustive approach. I did go thru the gtk+ tutorial, and info online, and have picked up gtk+ fairly well, but there are still lots of things that are left out. I had to look in the header files and then playa around to find something out, which did not bother me, but there are still some areas that I am weak in. I'd love a book as intensive as the Java Class Libs Vol 1 and 2 are, only with more examples, but until then I'll be looking at the source code and online documentation.
  • Try GtkGlArea. I have never programmed with this, but the source does have some documentation (in txt format as of 1.1.1 version).
  • Thats at http://www.student.oulu.fi/~jlof/gtkgla rea/ [student.oulu.fi]. Gotta remember preview.
  • GTK+ seemed a bit contrived when I tried to learn it. They are using OOP concepts in C. GTK-- (a C++ wrapper for GTK+) has the right idea, imho. As far as ease of use goes I have found that Qt is the best for getting a working app going with very little effort.

    To be honest, I found that the primary barrier to learning GTK+ was a lack of a good source of documentation. Maybe this book will change all that. I guess I'll have to pick it up and see.

    <SIG>
    I think I lost my work ethic while surfing the web. If you find it, please email it to crispy@crotch.caltech.edu.
    </SIG>
  • This topic has been covered over and over again. The result is the user preferences system. If you don't want to hear about something you can turn off that category. Of course this has one flaw. What if you want to hear about the "important" stuff but not the "less important" stuff within a certain category? I have an Idea for Slashdot:

    Every story should be given a ranking (1-10 or something) that is a measure of how important the current story is w.r.t. that category. ie. Redhat announcing it's IPO or a new release would be 10's but Redhat IPO updates would be 5's or something. Then a user could set a threshold for each category (0 shows no posts, 10 only the most important, 1 shows all posts)

    Of course this would be a purely subjective determination by the poster. If we wanted to get really hardcore into it then the importance could change due to moderator input/number of posts/number of positive moderator points given/etc.

    I know Rob has his hands full with updating the site all the time but this system sounds like a great Idea to me. What do the rest of you think?

    <SIG>
    I think I lost my work ethic while surfing the web. If you find it, please email it to crispy@crotch.caltech.edu.
    </SIG>
  • Yes I am well aware of the distinction between OOD and an OO Language and I make that distinction in my post. However C lacks many of the features that are the most useful and that C++ adds. Mainly polymorphism. Inheritance and templates make so much sense when working with objects that not using a language that supports those OO ideas just seems silly. I understand the decision to go with C instead of C++. The designers wanted a library that C programmers could use w/o learning a new language. That was a DESIGN decision made by the GTK+ people. I happen to think it was a poor decision. By using OOD they force the C programmers to learn to think in terms of objects anyway. They might as well use a language better suited for the task.

    <SIG>
    I think I lost my work ethic while surfing the web. If you find it, please email it to crispy@crotch.caltech.edu.
    </SIG>
  • I emailed rob and he told me it's in the .plan to add article rating. I guess great minds think alike, eh?

    <SIG>
    I think I lost my work ethic while surfing the web. If you find it, please email it to crispy@crotch.caltech.edu.
    </SIG>
  • He knows not what he says.

    You are obviously ignorant on this matter.

    When it comes to OOP Java is better than C++, and C++ is better than C. Not my opinion. Just plain fact.

    <SIG>
    I think I lost my work ethic while surfing the web. If you find it, please email it to crispy@crotch.caltech.edu.
    </SIG>

  • from the new-book's-to-read dept.

    That apostrophe just sets my teeth on edge. For those whose obviously slept through English class, here's how it works:

    • Contractions get an apostrophe where the apostrophe would go ("Here's an example")
    • Apostrophes are also used to indicate possession ("The book's cover art is impressive")
    • Apostrophes are not used to indicate plurals ("Hemos and CmdrTaco could both stand to read lots of books on grammar and usage")
  • so why post anything about "beta" redhat releases? eh.
  • Yeah, i know who ya are. I've been visiting the site for years, frankly this is the first time i ever posted off topic or started crap on here.

    i've loved slashdot, and loved its articles. But it truely seems biased.. as news for nerds and stuff that matters should be news.. not what joe schmoe runs, it shouldn't be any better or worse because 1 out of 10 use it or 6 out of 10 use it.

    the site is nice, maybe there should be a minor news section, maybe linux stuff should be rolled off from being headlines to its own group.. the bsd and be and other people have complained about this..

    personally GTK is good, i'm happy to see a book. but its not revolutionary, and its not any more news then redhat coming out with a beta, more so, i would have considered putting news up about Open Linux 2.3 with its huge jump in useability and functionality.. news about how the G4 works, not about how its marketed.. its news for geeks, not news for marketing peoples who play golf all the time :)

    hehe, i apologize for the off topic, and the continuation of going for a point that really has no point (since there really is no argument, this isn't my site to controll).

    But, i'd like to see a broader scope of whats considered news for nerds, and not news for gnome or news for redhat or news for linux, but whats technology doing for me.. that covers bds, linux, solairs, java, c, c++, perl, python, disks, ibm, microsoft, everything really..

  • "Apostrophes are also used to indicate possession ("The book's cover art is impressive") "

    Exception - possessive of 'it' does not get an apostrophe ("My widget broke its wizzo")
  • When in X, I have also found TkMan and TkInfo to be very very nice.
  • Some people HATE online documentation. For things like programming especially, it's a lot easier to have a printed copy on hand when you're trying to learn something. Those people will buy the book. I don't have any money at the moment, so I'll probably start reading this online.. but once I get some money I'm definitely going to buy it.
  • I come to /. for the NEWS(whether its new releases or whatnot). I like the fact that I can come to /. and find interesting news or when a new "beta" comes out... I don't like having to go to five million places. /. has everything in one spot and has the links to match.

    I agree with Finkployd when he says "if you don't like the articles, DON'T READ THEM!". Hell, I've skimmed over lots of articles :-)

  • I would also like such a book.

    I am trying to use GTK-- with great difficulty.
    The "stable" version does not have enough examples. The CVS version has lots of examples but I can't get them to build.

    Perhaps I will have to wait until I have time to build every thing from source (GTK+, gnome-everything, gtk--, glade, ...).

    I would highly recommend glade for using GNOME/GTK+ with C.

    I don't think GNOME will ever support C++ very
    well. Linux people seem to think C++ is a bad thing.
  • Look into glade.

    It stores the resources in XML. It also generates all the component
    initialization code and empty event handler functions for you.

  • I suggest that you start with the Harlow book (Developing Linux Applications with...), that will teach you what you need (together with the tutorial on the GTK+ site). As the reviewer said, you should have good understanding of GTK+ programming before you attempt the GTK+/GNOME book.
  • This book is excellent. The fact you can download it too is excellent. I wait to see what sales will be like - will people just read the online version, or will the book sell too? The latter, I hope. That way, maybe more Software books could be produced in this manner.

  • What are you smoking?

    It's 492 pages long with a small font, I wrote all the example programs, and it was not the first GTK+ book - Eric Harlow's was.

  • I don't know of an ORBit book in the works, though it would certainly be nice. Someone just contributed a nice CORBA tutorial which you can find on developer.gnome.org The GTK+ maintainers are writing a GTK+ book, which should be nice; and the GTK+ reference docs are moving along and will probably be published sooner or later

  • Information about the book (Score:5)

    by Havoc Pennington ( 87913 ) on Tuesday September 07, 1999 @01:00AM (#1698411)

    Please see http://developer.gnome.org/doc/GGAD [gnome.org] for more information about the book.

    Keep in mind that one book can't be everything. This is a sort of "intermediate-to-advanced GTK+/Gnome programming manual". An introductory tutorial, complete reference, CORBA book, XML book, etc. would all fill pretty thick books on their own. I already wrote 492 pages instead of the planned 350. :-)

    But I think you'll find lots of useful information in my book, and of course you can check it out online at the above URL and decide for yourself.

  • Everyone else here says its too technical... hmmm, you must be a technology demigod

Slashdot Top Deals

Vitamin C deficiency is apauling.

Close