The Official GNOME 2 Developer's Guide

Book Description

Developers who write programs for GNOME use the GNOME API. Working with the GNOME API is preferable because the program will conform to the standard GNOME program look and feel. It also allows the developer to use the GNOME specific libraries in the program, greatly simplifying the development process. The Official GNOME 2 Developer's Guide is the official GNOME Foundation guide to programming GUIs and applications using the GTK+ and GNOME API. Developed in partnership with the GNOME Foundation, this book is for programmers working with the GNOME 2 desktop environment. Each section begins with an example program that serves as a tutorial, then develops into a reference on the topic. Includes abundant, well-annotated examples. Knowledge of the C programming language is required, but no GUI programming experience is necessary.

Customer Reviews:

Definitely not for beginners........2007-06-20

Do not get this book unless you are already a skilled programmer. This is a quote from the introduction of the book: you must already have:

1. "experience in C, including pointers, dynamically allocated data structures, and pointers to functions. You should also be familiar with enumeration types and bit fields."
2. "a solid grasp of pointers to pointers (**types), where to use them, and how to extract and use the address of a pointer."
3. "understanding of C macros and the C preprocessor"
4. "fundamental understanding of Unix: processers, libraries, search paths, and so on."

Also, they recommend experience with callbacks and handlers.

So, again, if you are just setting out to learn programming as a beginner, this book will not help.

a clean introducion.......2006-08-03

This is a very clean and readable book introducing Gnome/Gtk2/GLib2 application developpement and can be also used for understanding GLib2 C utilities (strings, hashes, arrays, lists, trees...) and Gtk2 (treeview wigets, etc..). It also adds the Gconf stuff (an api for storing your app's configuration).

But unfortunately, neither the Bonobo graphical components nor the Corba services are presented. So, after reading the book, you still cannot know how to make your program communicate and integrate with other Gnome de facto standard apps. I hope some people will add one chatper or two about that in the next version..

Does What It Sets Out To Do.......2005-03-24

This is a pretty heavy duty programming book. The opening words say you should have, "Firm Programming Experience in C, including pointers, dynamically allocated data structures, and pointers to functions, C macros and the C preprocessor, fundamental understanding of Unix: processes, libraries, search paths, and so on."

Then the first chapter is on GLIB, a description of the more popular of the routines included in the library. The second chapter, GOBJECT has an opening note: "This chapter is dry and dense." -- Still, this chapter is one of the best descriptions of object oriented programming that I've ever read.

Finally in chapter 3 you begin to get into the heart of the matter. GTK+ is the toolkit for programming the GUI. Chapter 4 is on the GNOME Libraries. These two chapters are really the heart of the book and runs for about forty percent of the entire book. After that there is just some odds and ends that are left over.

This book, as clearly and succinctly as possible does what it sets out to do. It's not the simplest book on the shelf, but then again, neither is its subject.

Good book.......2004-08-21

As the author already states in the introduction the book doesn't cover all the aspects of gtk and gnome, because then the book would be over 1000 pages, but with what it covers it covers very well and you can have a great start with gnome programming.

The rest you can probably find out from the online documentation or the author has to write a part II

Excellent intro.......2004-05-16

I'm more of a command line kind of guy, but there are things better done in a graphical treatment. When this is true, I often resort to HTML, but that isn't always suitable either. Most of what I've read about GUI programming has left me feeling daunted by the learning curve, and the writing itself has mostly been difficult to read and unsatisfying

This book was a delightful exception. As its introduction promises, the content "lies somewhere between a tutorial and a reference". The code examples are often just the kind of things you would write yourself to test-drive your understanding; no unnecessary fluff. There are complete programs also, and these are downloadable from the No Starch web site.

Matthias Warkus has a real knack for explaining complex subjects. I particularly liked his way of explaining object inheritance, which is completely upside down from the way it is usually presented, and thereby makes a much more understandable case for using OO code.

The first chapter is an overview of GLib capabilies. I was quite surprised at the things GLib includes: I come from the days when you needed to buy commercial libraries to get features like memory management, linked lists, B-trees, etc. The second chapter covers GObject, which adds Object Oriented capability to standard C programming. That's an important aspect of Gnome: it is plain vanilla C with the OO stuff added on through the GObject library. For those of us who have yet to be entranced by C++, that's important.

Chapters three and four explain GTK+ and the Gnome libraries, the overlap between them, and hen you'd use either. Chapter five is a lucid introduction to Glade, the interactive development tool for Gnome. I was interested to note that Glade produces XML files that your programs references through calls to Glade libraries.

The rest of the book is miscellaneous coverage that wasn't covered elsewhere; compiling issues, configuration helpers like Gconf. I had ben previously unaware of the GnomeVFS discussed in chapter eight which allows your program to transparently access remote web servers and archive formats like PKzipped files.

Book Description

Tcl/Tk (Tool Command Language/Tool Kit) makes it fast and easy to implement any type of application, from games to network analyzers. Tcl/Tk is a full-bodied, mature programming platform used by NASA rocket scientists, Wall Street database experts, Internet designers, and open source programmers around the world. Tcl/Tk's multi-faceted and extensible nature make it ideal for developing end-user GUIs, client/server middleware, Web applications, and more. You can code completely in Tcl, use any of hundreds of extensions, call C or Java subroutines from Tcl/Tk, or use Tcl to glue legacy applications together.

Written from a programmer's perspective, Tcl/Tk: A Developer's Guide describes how to use Tcl's standard tools and the unique features that make Tcl/Tk powerful: including graphics widgets, packages, namespaces, and extensions. With this book an experienced programmer will be able to code Tcl in a few hours. In just a few chapters you will learn about Tcl features that allow you to isolate and protect your code from being damaged in large applications. You will even learn how to extend the language itself.

Tcl/Tk: A Developer's Guide clearly discusses development tools, proven techniques, and existing extensions. It shows how to use Tcl/Tk effectively and provides many code examples. This fully revised new edition is the complete resource for computer professionals, from systems administrators to programmers. It covers versions 7.4 to 8.4 and includes a CD-ROM containing the interpreters, libraries, and tutorials to get you started quickly. Additional materials in the book include case studies and discussions of techniques for the advanced user.

On the CD-ROM
*Distributions for Tcl 8.3 and 8.4 for Linux, Solaris, Macintosh, and Windows.
*A copy of ActiveTcl from ActiveState.
*The latest release of TclTutor.
*How-to's and tutorials as well as copies of all the tools discussed in the book.
*The author's "Tclsh Spot" articles from :login; magazine and the "Real World" Tcl/Tk chapters from the first edition.
*Demo copies of commercial development tools from ActiveState and NeatWare.
*Many open source Tcl/Tk development tools.
*Tcl/Tk design guidelines.

*Brings beginners up to speed quickly.
*Overview of Tcl development tools, popular extensions, and packages.
*Tips, style guidelines, and debugging techniques for the advanced user.

Customer Reviews:

Hands on approach.......2007-09-03

This book is fairly informal, with examples dominating the reference parts. I think I'll be using Brent Welch's book more as a reference though. There is good coverage of third party libraries and tools.

Getting Started with TCL.......2007-07-12

I was looking for a book to learn and start programming in TCL. The book has allowed me to do it. I had some problems with the way the informationw was presented. The book does not focus on TCL and the exact explinations for each commandis not present clearly.

The book does cover a lot of detail and there is a nice collection of stuff on the CD included so it is a good value for its cost.

Like it says, a developer's guide........2005-11-03

The book is in textbook format, with problems to be worked at the end of each chapter. The problems are of different levels of difficulty. No answers in the back.

The book itself is NOT concise, imho, and there seems to be many references to "see the CD" for complete information. Clearly, it is intended that you work with the CD to first accomplish the tutorials, and then use the book to polish what you've learned via the CD. The cute little "scroll" way of navigating about the CD works well in Windows, but doesn't work on my linux machine. The CD is also the only place where there is "A printable Reference"; at least, that's what the book says. I'm still looking for it.

You clearly get all the stuff you need to become a Tcl/Tk master, but with so much material, the reader is left to blunder through it all the best he can. To meet the goal of learning Tcl/Tk quickly as stated in the introduction, a "road map", "plan of attack", or an order of things to read on the disk should have been included.

Best book on Tcl programming.......2004-02-21

[I'm stingy in my ratings. I could easily give this book 5 stars, but I try to use the entire rating scale.]

This book is the best available complement to the free HTML documentation (which is available online, or on CD in many books, including this one). I like the latest version of the Welch book, with its vastly improved index, but I find the explanations to be a bit sparse.

For example, I am an experienced programmer in several languages, but I still had a lot of questions about local scoping vis-a-vis namespaces after reading Welch and the docs. Flynt made this topic transparent, with diagrams and examples. I also liked his example of building a tree data structure, which demonstrated to me better than anything that Tcl is simply the wrong language for building trees.

That brings me to what I dislike about this book. The code examples are sometimes too long. In my opinion, long code should be only on the CD, to save paper space. And as the book is shorter than Welch's latest, I think the space should not have been wasted.

About 1/3 of the book is devoted to Tk, similar to Welch. I have no interest in Tk anymore, so that is all a waste for me. (If you ARE interested in Tk, Effective Tcl/Tk programming is a great source.)

There is a fair amount of info on the C library, but I think that Ousterhout's old book is still the best place for that. However, Flynt provides great advice on practical ways of interfacing with C/C++ (SWIG, Starkits, Starpacks).

He also details the pro and cons of various Tcl tools, some free. This sort of information goes out of date quickly. For example, the author already mentioned privately to a friend that "nagelfar" is now his own favorite syntax checker. But at the moment, most of his info is current.

In short, this is the best book for Tcl developers. But please consider Lua as an alternative interfacing language.

Excellent book for Tcl/Tk developers of all skill levels..........2003-06-30

This book covers the Tcl language and the Tk toolkit in exhaustive detail. It works very well as an introduction to Tcl/Tk and as a reference guide for developers more experienced with Tcl/Tk.

KYLIX: The Professional Developer's Guide and Reference

Average customer rating:

Kylix Reference (but without Database or Internet coverage)
If you only buy one Kylix book..
Better than the best
The best general-coverage Kylix book yet.

KYLIX: The Professional Developer's Guide and Reference
Jon Shemitz
Manufacturer: Apress
ProductGroup: Book
Binding: Paperback

General | Operating Systems | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books
Similar Items:

ASIN: 1893115895

Book Description

Kylix: The Professional Developer's Guide and Reference is a comprehensive guide for developers wishing to make quick inroads into developing native applications for the Linux platform. Consisting of fourteen chapters divided into five sections, author Jon Shemitz's book covers a wide-ranging gamut of topics relevant to both novices and experts alike.

Section One, "Object Pascal," is devoted to a quick introduction to Object Pascal, Shemitz quickly brings non-Delphi/Kylix programmers up to speed regarding the foundational concepts of one of the platform's core languages.

Section Two, "Kylix," turns the reader's attention towards the core functionality of the Kylix application, including information regarding basic configuration and platform navigation, object design and manipulation, using libraries, and component creation.

Section Three, "Linux," is devoted to programmers migrating from the Windows platform to Unix, providing a general survey of those components that a Unix novice would be best-served to understand when developing native Linux applications.

Section Four, "Projects," is devoted to illustrating how two practical applications are created in Kylix.

The book closes with Section Five, "Appendices," which includes a comparative reference for programmers migrating to Kylix from Visual Basic and Delphi backgrounds. Valuable information regarding optimization and deployment is also included.

Learn more about the author and Kylix: The Professional Developer's Guide and Reference at http://www.midnightbeach.com/kylix/.

Download Description

Kylix: The Professional Developer's Guide and Reference is a comprehensive guide for developers wishing to make quick inroads into developing native applications for the Linux platform. Consisting of fourteen chapters divided into five sections, Shemitz covers a wide-ranging gamut of topics relevant to both novices and experts alike.

Section One, Object Pascal, is devoted to a quick introduction to Object Pascal, Shemitz quickly brings non-Delphi/Kylix programmers up to speed regarding the foundational concepts of one of the platform's core languages.

Section Two, Kylix, turns the reader's attention towards the core functionality of the Kylix application, including information regarding basic configuration and platform navigation, object design and manipulation, using libraries, and component creation.

Section Three, Linux, is devoted to programmers migrating from the Windows platform to Unix, providing a general survey of those components that a Unix novice would be best-served to understand when developing native Linux applications.

Section Four, Projects, is devoted to illustrating how two practical applications are created in Kylix.

The book closes with Section Five, Appendices, which includes a comparative reference for programmers migrating to Kylix from Visual Basic and Delphi backgrounds. Valuable information regarding optimization and deployment is also included.

Customer Reviews:

Kylix Reference (but without Database or Internet coverage).......2002-10-09

When I received this book, I was impressed by the fact that it contained 943 pages on Kylix - without covering any database or internet development. Now that I finished the book, I'm even more impressed. Not by what's not in the book, but by what's actually covered in the book.
Somehow, the book reminds me of the years I spent at the University of Amsterdam (back in 1983), and first learned to work with UNIX and Minix.
I'm not sure why. Maybe the fonts, maybe the quality. But one thing is for sure, like the cover said: this is not a Delphi book 'ported' to Kylix. This
is a true Kylix/Linux Development book, and as such, I'm sure every Delphi developer can learn something from it.

The book consists of four sections, and a number of appendices. The first section contains about 250 pages about Object Pascal. But before we
start the first section, there's chapter 0: Hello Kylix, in which the author explains why Kylix is great, and what this book will offer (and what not -
so you'll know right away). It also explains where to download the sample code, and then continues with a first hands-on getting started tour in
Kylix.
The first real section of the book consists of four chapters (252 pages) and is about Object Pascal. From data types and datastructures to program
syntax and structure. As a Delphi developer, it was the 'least interesting' section of the book to read, although I would still recommend browsing
through the pages, since there are numerous tips or footnotes that are worthwhile to read (as the back cover says: "even long-time Delphi
programmers will find some surprising details here", such as the part on libraries and dynamic linking). In fact, it reminded me of the excellent Pascal
textbooks I read during my study (mentioned before), and I can recommended it to anyone who wants to learn Object Pascal.
The second section of the book extends the 'simple' Object Pascal languages and moves on to Kylix - the RAD Development environment on Linux.
In five chapters, we'll learn how to use Kylix (the IDE, designing, debugging), and the components that can be used with Kylix. When I say
components, the author has split them in a few different chapters. First, we get the Visual Objects (VisualCLX components on top of Qt), followed
by a chapter about Foundation Objects (the non-visual components and support classes such as collections and streams, as well as threads), and
finally library routines (only the most important ones, like Strings, Dates, Maths, etc.), and component building in Kylix. Although - like I mentioned
before - this is not a Kylix 'port' of a Delphi book, the author does place 'cautions' and notes in the chapter to highlight some of the differences
between Delphi and Kylix that are important to Delphi developers. The repeated reminder in the border that keeps telling us that "Kylix is not Delphi"
grows a bit tiresome after a while, but the notes themselves are good points.
The third section of the book is about Linux - for Windows developers, and using Kylix. It covers Linux and Linux programming from a Windows
programmer's perspective, explaining the differences, and showing what to do (and how to do it differently) under Linux. Subsections include files,
memory, processes, regular expressions and scripts (this brought back some fond memories when I first used UNIX almost two decades ago). The
final chapter in this section introduces X and Qt (we've seen Qt before in the previous section). It's only a short chapter, which is good, since I
consider this only background information (to give an architectural overview of X and Qt). VisualCLX is build on top of Qt (and X) and in theory you
should seldom have to sink down to the API level.
The fourth section of the book is about entire projects, and contains two chapters: one about a visual find utility (imitating Windows' Find Files),
and a chapter on Mandelbrot 4 (I wasn't too interested in this, but the results look very nice).
Fortunately, the book wasn't finished after this last chapter, since we still have a number of interesting appendices. Covering topics such as "Kylix
for Visual Basic programmers" (there may be more than you think), "Kylix for Delphi programmers" (a bit late if you read the entire book already, but
it gives a short summary of the most important changes and gotchas, including references to chapters that cover these in more detail). So Delphi
developers may want to start reading the book with Appendix II. Other appendices cover topics like Optimization and a BASM quick reference,
although these two are too short to be of real use I'm afraid. Appendix V on Deployment is a whole lot better, especially since this is indeed an ever
returning Kylix developer's FAQ. Well written, and helpful for deployment on systems that don't have Kylix installed.
Apart from the regular text, the book contains numerous little "notes" that contain tips, background information or just useful techniques worthy to
highlight. The index seems complete, but could use a smaller font to get a better overview. Syntax highlighting is used in source code listings,
which I always consider to be very helpful. Unfortunately, on a few places it was missing or inconsistent (just as I sometimes didn't agree with the
source code indentation and layout, but these are personal feelings of course).
Back in the beginning of the book, in Chapter 0, the author explains that he wants to write a 'classic' book. The book that a bookstore would carry
if it had only one Kylix book. I'm not sure if this book is the classic Kylix book (not without database or internet coverage), but it sure is a great
book to learn Kylix as well as Linux - for everybody!

And when it comes to the missing sections (on database and internet): I can also recommend Delphi/Kylix Database Development by Eric Harmon, as well as the Kylix Developer's Guide (for which I wrote the web development chapters).

If you only buy one Kylix book.........2002-06-27

This book is a whopping 1000 pages and never did I get the feeling that _any_ of it was fluff. Not only does it give you a thorough exposition on writing programs in Kylix, it also delivers vital information on writing and running programs under Linux. Many programming books come with source code as does this one, but I almost always never use such code because of poor quality or a lack of relevance to my project. Within 10 minutes of starting this book I had found critical uses for several of the modules Shemitz provides, and I see a lot more that I'll be using in the future.

There's a wonderful chapter on Kylix that existing Delphi programmers will find absolutely invaluable. In addition, programmers coming from the Windows environment like me, will find some terrific chapters on the Linux knowledge you need to get up to speed fast, saving you from torturous safaris through the Internet. Without question, a terrific book.

Better than the best.......2002-06-12

Well done, Jon Shemitz. Two things jump out from this book: first, lots of text and virtually no screen shots. That means a LOT of very erudite content. Second, brilliant organisation. It's not a feature of many Delphi/Kylix books, even the worthy ones, and it is manna when it droppeth.

The book touts itself as "a comprehensive guide for developers wishing to make quick inroads into developing native applications for the Linux platform". Comprehensive it is, but this is no quickie how-to. This author goes the extra yards and provides good, lucid explanations for why a certain thing is as it is. It reflects excellent research, meticulous QA and the trait of the true teacher, to share what he knows. As a result, I'm finding topics in this this book that have eluded me for years of Delphi work - being absent from the popular titles, the Borland help and the Borland knowledgebase.

When (not if!) you buy this book, pay attention to the Notes panels and the footnotes. Shemitz (or his editor) has been very tight about delivering the story. His post-its and those vital snippets of experiential background are not buried in the main story but are distilled out expertly and consistently into these two reader aid devices. The plot stays right on target and those tricky bits are just where you want them, without having to dive off to a cross-reference.

Because I live in a remote area, I have to buy books "sight unseen". Hence, my tech library is a "lucky dip" of useful titles and doorstoppers. With this one, I really lucked in. I think it was a gutbuster to write and consider it worth every drop of blood, sweat and tears.

The best general-coverage Kylix book yet........2002-01-22

There are an infinite number of ways to skin any given cat, and when covering a new RAD environment, which one you use depends almost entirely on who your target audience is. Jon Shemitz has written his book for the experienced programmer coming to Kylix from other RAD environments on platforms other than Linux/X. This, I feel, is the source of Kylix's user base: Not the casehardened command-line Unix-lifer gcc guys, but people who have been using Delphi, Visual Basic, or Visual C++ under Windows.

For people like that, it's a natural. Jon begins with a "Hello Kylix!" project to let people get their bearings within the Kylix idea, and then systematically explores the programming language (object Pascal), the environment and toolset (Kylix itself) and finally the underlying platform (Linux, Qt, and X.) People who already have their Unix scar tissue can skip the Linux section, but Windows expatriates will be glad it's there. The coverage of Object Pascal skims the simple stuff and emphasizes the subtleties that most books gloss over: inheritance, properties, class references, and the rest of the OOP machinery that far fewer people understand than claim to. (For that part of it, I recommend this book even to people who are sticking with Delphi under Windows!) The Kylix coverage, again, goes for depth: The section on threads is clearer than anything else I've read on that topic. The Unix material is well-chosen, and I learned far more about Qt from this book than I did from the Qt doc.

The overall quality of the book is very high. The writing is superb, and the screen shots are well-chosen and clearly reproduced. Scattered throughout the text are "Kylix is not Delphi!" tips, which people coming to Kylix from Delphi had better read. The text is set in smaller type than many "fat books" on programming, so I would guess this 950-page book represents about 1100 pages using conventional layouts. No fluff, good example code, fine index. Finally, APress has at last dropped the CD stuck into the back page. The example code may be downloaded in tarball form from the publisher Web site.

Book Description

A comprehensive and practical guide to PAM for Linux: how modules work and how to implement them, covering 11 common modules, and installation of third-party offerings. Also covers developing your own modules in C. First this book explains how Pluggable Authentication Modules (PAM) simplify and standardize authentication in Linux. It shows in detail how PAM works and how it is configured. Then 11 common modules used across UNIX/Linux distributions are examined and explained, including all their parameters. Installation of third-party modules is discussed, and the development of new modules and PAM-aware applications is outlined PAM-aware applications reduce the complexity of authentication. With PAM you can use the same user database for every login process. PAM also supports different authentication processes as required. Moreover, PAM is a well-defined API, and PAM-aware applications will not break if you change the underlying authentication configuration. The PAM framework is widely used by most Linux distributions for authentication purposes. Originating from Solaris 2.6 ten years ago, PAM is used today by most proprietary and free UNIX operating systems including GNU/Linux, FreeBSD, and Solaris, following both the design concept and the practical details. PAM is thus a unifying technology for authentication mechanisms in UNIX. PAM is a modular and flexible authentication management layer that sits between Linux applications and the native underlying authentication system. PAM can be implemented with various applications without having to recompile the applications to specifically support PAM. This book provides a practical approach to UNIX/Linux authentication. The design principles are explained thoroughly, then illustrated through the examination of popular modules. It is intended as a one-stop introduction and reference to PAM. This book is for experienced system administrators and developers working with multiple Linux/UNIX servers or with both UNIX and Windows servers. It assumes a good level of admin knowledge, and that developers are competent in C development on UNIX-based systems.

Customer Reviews:

Some good info. Not as much as I hoped........2007-08-23

The information contained in the book was easy to understand but it did not go into as much detail as I had hoped it would about what I was purchased it for.

Average customer rating:

Nothing exciting here
I shouldn't have bought this book.
A Fantastic Book
Good Book worthless CD

Kylix Developers Guide (With CD-ROM)
Charles Calvert , Marjorie Calvert , John Kaster , Bob Swart , and David Intersimone
Manufacturer: Sams
ProductGroup: Book
Binding: Paperback

General | Operating Systems | Computers & Internet | Subjects | Books

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 0672320606

Book Description

Delphi for Linux (Kylix) Development includes three main themes. First, the book recognized that much of its audience will be Windows developers who need to understand basic Linux development strategies, so there will be information throughout the book offering insight on how to leverage Windows development knowledge to the Linux platform. There will be significant coverage of the tools and features of the Kylix environment, but the book assumes that readers will be familiar with RAD development tools generally. Finally, there is extensive coverage of how to apply the CLX library in building solid applications. The book will also discuss cross-platform development strategies.

Customer Reviews:

Nothing exciting here.......2005-07-20

I've been programming in Delphi for over 10 years, so I've got the basics pretty well nailed.

Plus there's not much here about what is unique about Linux / Kylix / CLX.

The Web section was particularly disappointing. No depth.

Maybe a decent beginner's book.

I shouldn't have bought this book........2002-12-21

When I bought the book, I thought I would be able to use Kylix software because the book has the open and trial edition.

But both of the editions asked me to type serial number and authorization key. What the hell are they? Have you ever seen any trial version of software asking you type serial number?

And I asked the publisher but they never repiled.

If you don't have enough money to buy the license, don't buy this book. It's useless.

A Fantastic Book.......2002-05-20

Forget the CD as I have never bothered to even use it. The book itself is a treasure chest of information. Well written, robust and easy to follow. Kylix Developers guide gives you the fundamentals as well as the advanced features you will require to become a well versed Kylix/Pascal programmer. A particular point which I enjoyed is how the authors teach you how to program outside of the components for X, which teaches you to actually program for X directly. Databases, Games you name it, it is in there.

Another book I would recommend is LEARN OBJECT PASCAL WITH DELPHI. Though it says delphi, the langauage of Pascal is thoroughly covered in this book and translates quite well to Kylix.

Good Book worthless CD.......2001-12-27

The author has done a fairly good job of writing a book for Window programmers to use and learn Kylix on Linux. But I bought the book to use the Open Edition, but the install directions are not current with the layout of the CD that ships with the book. Be prepared to do some work to get the install correct.

Book Description

A guide for UNIX developers who want accurate information on getting up to speed with Mac OS X and its software development environment, this book provides programmers all the information they need to understand and use the operating system, its development tools, and key technologies such as Darwin, Cocoa, and AppleScript. Users are introduced to the UNIX-based foundations of Mac OS X and shown how they fit into Mac OS X architecture. Also provided is coverage of both GUI and command-line software development tools, realistic programming examples that developers will encounter, and a discussion of Macintosh-style software development.

Customer Reviews:

Broad, not deep.......2004-04-27

This book is a case in point for accurate titles. The book is exactly what it says it is, a wide overview of all of the different ways for 'Programming Mac OS X'. It starts with a brief history of the operating system, then talks about the operating system basics. It then covers at a high level building applications with Java, Objective-C, Carbon, Applescript and Perl. This includes sections on the tools to use to develop in these languages, and in some basic introductions to get you started on that platform.

In Manning style the graphics are effective, and the code samples are not overused and are well commented. Chapters three and four, which cover Project Builder and the standard compilers, stand out as the heart of the book. Chapter seven, on Applescript, is particularly appreciated because of the lack of documentation or books on this subject.

The book fills a unique roll. It covers all of the different programming possibilities at a level that gives you perspective of the entire playing field. If you want to drill down into say, Java programming, you will need to buy another book. But if you are unfamiliar with OS X and you are looking to program for it, you should take a look at this book to get a feel for the possibilities.

Good Introduction to Mac OS X programming tools.......2003-03-28

The intent of this book is to introduce Unix developers to Mac OS X. As such, I think it does a pretty good job. It doesn't go in to great depth; for example another reviewer complained about its lack of coverage for Carbon or mixed mode programming. That's not entirely fair though given its intent: while some Unix developers may be interested in producing OS9 capable apps, my bet is that most are just going to ignore anything prior to X entirely - and they should! There is a small appendix that covers the history of Mac OS prior to X, but it does not cover programming and I don't think it should.

I do have some minor criticism. I had never even looked at Project Builder/Interface Builder (the programming IDE) before picking up this book. There's a good sized introductory chapter on using this for a simple project. I worked through it, but it wasn't entirely easy sailing. I'm not sure whether that was because Project Builder has changed slightly since this writing, or if the author is just so familiar with it that he accidentally used incorrect language here and there. In any case, I found myself confused at certain points. However, there were no show stoppers: if you are a developer, you will understand the goal and enough of the concepts not to get hung up by these small errors or omissions. While I might wish these things were more carefully reviewed by having an unfamiliar user actually run through them, I don't see this as a major weakness at all.

In addition to Project Builder and Interface builder, this covers Objective-C, and Applescript. It isn't going to teach you much about either of these; you'll need other books for that. But it will introduce you to them, lead you through building a simple example applicatio, show you how the Apple debugging tools work, and show you how to create HTML documentation for use with Apple's Help Viewer.

Better for UNIX developers who have never seen a Mac before........2003-03-22

This was a pretty average book in my opinion... not terribly compelling in spots, and occasionally a bit over-the-top in its love affair with the Mac.

IMHO, it's really a book designed to show UNIX developers how to become Cocoa developers, and if you fall into that category of developer and are new to the Mac, then the book may be worth a quick read.

What this book won't help you with is working in Carbon environments, or working in mixed MachO/CFM environments, or working on projects that are built partially with Project Builder and partially with other tools (such as Code Warrior).

Unfortunately, most commercial Mac based development has to deal with one or more of these mixed-environment issues for a variety of reasons I won't go into here.