Product Description
The Tcl language and Tk graphical toolkit are simple and powerful building blocks for custom applications. The Tcl/Tk combination is increasingly popular because it lets you produce sophisticated graphical interfaces with a few easy commands, develop and change scripts quickly, and conveniently tie together existing utilities or programming libraries.One of the attractive features of Tcl/Tk is the wide variety of commands, many offering a wealth of options. You'll find that a command or option probably exists to provide just what you need.This valuable quick reference briefly describes every command and optionin the core Tcl/Tk distribution, as well as the most popular extensions.Keep this book on your desk as you write scripts, and you'll be able to findalmost instantly the particular option you need. Covers: core Tcl and Tkcommands and Tk widgets, C interface (prototypes), Expect, [incr Tcl] and[incr Tk], Tix, TclX, BLT, Oratcl, SybTcl, and Tclodbc. ... Read more

Customer Reviews (12)

Good reference for Tcl/Tk 8.0, but now outdated
This book really needs to be updated for the latest version of Tcl/Tk, as there have been a number of important additions since it was published in 1999. For example, all the new string commands and regular expression enhancements added in 8.1, the new file operations added in 8.3, and the new list commands added in 8.4, not to mention all the new Tk widgets (e.g. spinbox, panedwindow). To learn about all the new features, I'd recommend that you get the latest version of Brent Welch's "Practical Programming in Tcl and Tk" instead. The documentation that comes with Tcl/Tk is the ultimate authority, and is basically what this Nutshell book consists of, albeit for the old 8.0 version. It's basically just a copy of the old manual pages.

I think this book is just too old to be useful anymore, especailly since if you have Tcl/Tk installed then you already have all the current documentation. And there are virtually no examples given. The Chapter on The Tcl C Interface is basically the contents of the tcl.h header file. One reason I give it 2 stars instead of just 1 is that it does have some chapters on some popular Tcl/Tk extensions, like Expect, Tclx, Tix and Blt, even though they're pretty much just the manual pages for those extensions.

Disorganized, incomplete, and unfriendly
The book has lots of information but one has to go through lots to loops to get to where the information should be and then it may not be there.

E.g., the index has no mention of the 'wm' command--one that I often encounter.

E.g., another book implies that there is a canvas command 'delete all'. After I finally got to page 61, I found the 'delete' command but NOT any hint that one can use the 'all' command to delete all the objects on the canvas.

Another example, even though the book purports to cover TK--the visual side of the language--I find just one chart, .

Needless to say, there are very few examples.

Good reference, not so good for beginners
If you need some hand-holding and are just getting started with TCL then this book is not for you. Tcl/TK in a nutshell is exactly what the title says, a desktop quick reference.
Don't expect many examples or explanations.

Compared to Perl / C style languages TCL is a little weird to look at and takes some getting used to. And it's easy to get tripped up if you aren't already experienced with the language. A lot of the material in the book doesn't go any deeper than the TCL man pages. So beginners, get a different book / tutorial to learn the language.

If you are proficient in TCL than this book would make a great reference, but as a beginner (to TCL, not to programming) a lot of times I had to supplement what the book gave by searching the web for examples to making things clearer. But it is definitely useful for looking up rarely used / obscure commands that you may have forgotten.

Even though the book lacks a lot of examples and hand holding it is very comprehensive and covers a lot of material.

Good reference, but don't expect anything else.
As a reference goes, this is pretty good. I've noticed a certain hit or miss aspect of the O'Reilly Nutshell series. This one is more of a hit for me personally. Still, I'm already bumping into things I wish this book covered. stooop, for one thing. There isn't much here that you won't find in the online documentation, but it can be very nice to have a paper copy.

Basically, this book was what I was expecting it to be. Nothing more, nothing less.

it's a nutshell book ... stuff you can get online
this is the tcl book i keep handiest, even though it doesn't offer me much of anything beyond the manual pages. what it does offer is a compendium of tcl, tk, expect, tix, blt, itcl, itk, tclx, and the like's references.

i've always been disappointed in tcl's online documentation. you can easily reproduce the lion's share of this book by just printing out the manual pages. however, having them bound and handy can be a relief. it does include some sample code (which you can typically find online), adding some value.

it's a nutshell book, though, and nutshell books are typically like this. o'reilly's had this series for years and they've always been of questionable value for some people (myself included). you wont learn a language this way, you wont even improve your programming this way, you'll just have a handy printed reference manual. i haven't yet found it to be incorrect (but i didn't go looking), so that's got to say something.

don't pay full price for this one. ... Read more

Product Description
This book is a tutorial that describes when and how to use Tcl and its add-on extensions, and how to embed it within other programs. Dozens of sample applications illustrate the structural basics and syntax of Tcl, and explain how to program both simple and advanced applications. The CD includes the latest version of Tcl and Tk, along with source code, executables, and Tcl freeware.Amazon.com Review
Graphical Applications with Tcl and Tk is an accessibleintroduction to Tcl and Tk that is ideally suited tobeginners. Although the title suggests that the book focuses primarilyon graphical applications, Johnson provides a thorough, if notexhaustive, introduction to the most important commands in Tcl andTk. The clean, well-laid-out text makes it easy to find theinformation that you need quickly. Simple examples illustrate almostall of the commands and ideas presented in the book.

GraphicalApplications with Tcl and Tk covers Tcl 7.5 and Tk 4.1. Althoughthere are newer versions of Tcl and Tk, the material covered in thisbook should satisfy all but the most advanced programmers. Theenclosed CD-ROM contains versions of Tcl/Tk for Windows 95, 3.1, andNT, as well as several Unix versions. ... Read more

Customer Reviews (5)

Useful Book
I'm an electronic engineer and I view programming as a peripheral skill necesssary to get the job done. This normally involves knowing what you want the program to do and researching existing literature till you find how to make it happen. Graphical Applications with TCL/TK made the job of creating custom GUI's relatively easy. The book is well written with working code modules for generating various widgets. The later chapters tie these modules together into standalone working programs.The CD has a contributions directory with programs from different authors that was helpful. It would have been nicer to have a few more Windows based contributions but I believe that is a symptom of TCL's UNIX ancestry. I've read some other TCL/TK programming books that were a waste of time, don't bother this is the tool you need.

Excellent book for the 2nd step
This is definitely an excellent book for the beginner or even "advanced" beginner. After reading Ousterhout this book helps to find out about various ways to use Tcl in a more practical manner. Section-1 introduces into all the basic stuff that people usually want to use Tcl for. Section-2 gives good hints on how to write more complex applications. The last chapters though are getting somewhat superficial. But that is when you already became a more sophisticated programmer and need more sophisticated books.

Great introduction to TCL/Tk programming
Simple and numerous examples demonstrate the many tcl/tk commands, presented for both unix and windows.Very good for reading and doing cover to cover The emphasis is on graphical layout, which I have found to usuallybe the most difficult part to quickly become proficient at.

Itsorganization does not lend to rapidly looking up commands or syntax, butthat is what the man pages are for.

Overall it is well written and easyto follow, and very exhaustive in its coverage.

Great book for Tcl/Tk beginners!
This must be the ultimate beginners book for Tcl/Tk. Lots of examples and step by step explanations. Good for both Linux/Unix and Windows programmers!

Nice book for Tcl programers who want to move to Tk.

This is a very nice book, with a lot of examples and illustrations that gives an intermediate Tcl programmer a very good introduction to Tk. Ignoring the fact that the book work with an older version of Tcl/Tk (but then,new versions are comming out every month), I would recommend this book to most programmres.

This book is not for someone that have never programmed before, but if you have programed before (in any language) this book will give you a good starting point for writing GUI application with Tk.

One bad thing: the book's cover makes promises that the book itself does not keep! ... Read more

Product Description
This book will fill a void in the current Tcl/Tk bookshelf. It is written to the latest version of Tcl/Tk (8.0, perhaps 8.1, depending on Sun's release schedule) and addresses Tcl/Tk under Windows as well as Unix.It includes discussions on proper coding techniques, instead of just language syntax. Clif Flynt gives readers a very 'hands on' book, with an emphasis towards allowing a reader to pick up the book as needed to find the answer to a question, instead of assuming that it will be read cover to cover.



· A sufficiently detailed overview of the Tcl/Tk language that readers can determine if this is the proper tool for their project.
· Enough information that an experienced programmer can start working with the language immediately.
· Hints and tips on how to use the language effectively.
· Templates that will minimize the new language learning curve.
Macintosh, Windows, Unix, Linux
User requirements would be Windows 3.1 with 32bit DLL, Windows
95, Windows NT, Macintosh, Unix, Linux, or Solaris.A 386 or better CPU, 4 Meg Ram, and 4 Meg free disk space. Different packages will have different disk space requirements.A good guess is 2 Meg / package.


... Read more

Customer Reviews (12)

Just what I was looking for
I've been writing code for 8 years and despise books that think I need a lesson in theory.Luckily, Clif Flynt's book is targeted at people like me.I've read the first 4 chapters on Tcl and then skipped ahead to Tk.No problem.It does lack a certain amount of detail, but nothing a scan through the Tcl/Tk docs wont fill in.Plus the CD has some good examples and some interesting (although largely outdated) tools.

TCL is a programming language.
Combining the best of C and object Pascal, TCL offers the programer many of the tools needed for Internet development "HTTP, HTML, POP3, SMTP, TclPro Debugger". When I realized there was a CD packaged with the book I was very quick to install the TCL compiler. It's at least as good as my latest "Borland C++ Builder" aka "Delphi".

My only complaint: "What the heck are Tk MegaWidgets"?

A great book!
This book is a pleasure to read and to use as a reference.Among its features are: use of a recent version of Tcl/Tk, an orderly presentation, straightforward an well-motivated examples, a useful index, a CD-ROM witheasy-to-install and useful selections, good typesetting, and high qualitypaper.It's been a real hit in my Unix programming class.

Best general Tcl book so far
I find Flynt's presentation of information very clear.He presentsdifficult topics in the order that makes the most sense, tells you justwhat you need to know without excess verbiage, and gives clearexamples.

I've been using Tcl/Tk for over six years, and have severalbooks on the subject, but this is the one I reach for first.Other booksconcentrate more on specialized topics like Web programming, but this is asolid text and reference for the basics.His reviews of extensions andother useful packages are also very helpful

Too focused on Tk
This book is somewhat imcomplete.It focuses too much on Tk and widgets and lacks a multitude of commands.I have found many more commands for Tcl on the web that are not even hinted to in this book.This book isespecially not good for sockets programming. ... Read more

Product Description
Just what you need -- another programming language that promises to transform your Web site into an interactive multimedia powerhouse. But before you roll your eyes, consider this: Tcl/Tk, the new scripting language from the folks who gave us Java, not only adds interactivity and multimedia to Web pages, but it's also easy to use -- even for non-programmers. And Tcl/Tk For Dummies makes easy-to-use even easier.A practical, comprehensive reference, Tcl/Tk For Dummies introduces you to the language and what you can do with it. Authors Tim Webster and Alex Francis quickly get you up to speed writing your own tclets, compact programs that run within Web pages viewed in the Netscape Navigator or Microsoft Internet Explorer Web browsing programs. The authors spell out the language's simple syntax and present the commands, procedures, functions, variables, and other elements that make up Tcl/Tk. They also show you how to use widgets, convenient, ready-to-use components that you can add to your Tcl/Tk programs.In addition, Tcl/Tk For Dummies provides hands-on information on how to do things likeDevelop useful applications that run within a Web browser as if they were traditional, stand-alone programs running under a regular operating systemWrite platform-independent scripts that run on Windows, Mac OS, UNIX, and even on BeOS platformsCreate animation and games to add value and fun to Web pagesImprove your Web server's performance by shifting the burden from server-side CGI scripts to client-side Tcl/Tk scriptsPlus, the Tcl/Tk For Dummies CD-ROM includes the Mac and Windows Tcl/Tk 8.0 development software with Wish 8.0, and HTML editor, and plenty of sample code from the book. Amazon.com Review
Unix users like to write scripts--automated routines thatperform tasks more quickly or efficiently than manual labor but areeasier to write than full-fledged compiled programs. You can usescripts to automate many routine tasks, such as the process ofcreating hundreds of new user accounts. Two of the newest scriptinglanguages are Tool Command Language and Tool Kit, most often referredto collectively as Tcl/Tk. Tcl/Tk for Dummies effectivelyintroduces this utilitarian suite of tools and promises to have youwriting useful scripts quickly.

Authors Webster and Francis beginwith Wish, the editor-with-training-wheels of Tcl/Tk development.They promptly move ahead into writing source code with a text editor,requiring the reader to write a simple Tclet in the process. Theauthors then document the language, devoting chapters to commands,variables, substitution, control structures, lists, and strings. Afterthat, Webster and Francis document procedures, functions, andwidgets--which you use to create graphical interfaces for Tcl/Tkprograms--and their exposed services.

The final portion of thisbook will prove useful to those attempting to solve simple problemswith Tcl/Tk. The authors assemble a menagerie of Tclets (on thecompanion CD-ROM) that you can use as they are or modify to fitslightly different purposes. These canned Tclets include someInternet-ready samples, which illustrate the languages' capacities towork with URLs and network data. ... Read more

Customer Reviews (6)

don't even bother with this book
if provides a VERY general overview on creating a few buttons and using wish... Thats it. It can be used to show someone what tcl can do. ...In general, the technical books that are "For Dummies" ...[are no good].

If your a programmer (or hope to write widgets in tcl/tk) get a different book.

This book is by Dummies, not for them!
I was highly disappointed by the quality of this book. This book is so full of bugs it should only be used for kindling (you might get your money's worth). Previously, I had wonderful experiences with 'Dummies'books, but this one is awful. I tested many of the examples and was forcedto edit many of them for the programs to work properly. Also, many of thefigures and screenshots are out of place -- or their captions are irelevantto them. One other complaint -- a big one -- I don't know if this happenedto all of the CDs, but mine didn't have close to everything that the bookadvertises! Speak of aggravating! The book will sometimes refer to anexample that is on the CD, but when you look for it, it's simply not there.Oh, by the way, I only gave this book a star because I was unable to submitthe review otherwise!

This book couldn't be worse
This book is terrible. I picked it up on sale forat a local computer store, but it wasn't even worth that price. This book is like a cockroach infestation; the number of bugs is unbearable. Examples don't appear in the right places, and they appear with the wrong headings, as doscreenshots, etc... I'm not sure whoever proofread this one before it wentout, but they should be fired. Do yourself a huge favor and buy anotherTcl/Tk... this one is best avoided.

Not as good as other "Dummies" books.
Bought this book because I was so impressed with "Perl 5 for Dummies", but "TCL/TK for Dummies" doesn't measure up. Lots of mistakes, no good reference material in the appendix section, and notvery well organized. An example irritant is a reference to more informationon the "listbox command" in chapter 22... while the book endswith chapter 21.

Easy to follow.Humurous and easy reading.
I have had the opportunity to read several programming books in the past year as a student.The text books used in school are hard to read and even harder to follow.Learning a language from the text books offered withoutthe aid af an instructor would be impossible.This book, on the otherhand, makes it possible for anyone to learn and master the proceduresrequired to use TCL in an industrial environment. ... Read more

Product Description
Sams Teach Yourself Tcl/Tk in 24 Hours quickly empowers you to create your own programs using the popular open-source Tcl language and the Tk toolkit. Using their classroom-proven methods, and the success of their popular Tcl/Tk Cookbook, the authors provide you with an understanding of the Tcl language, and guide you through the use of the Tk toolkit, enabling you to create your own Tcl/Tk programs quickly and easily. The 24 1-hour lessons include Tcl expressions, control structures, lists and arrays, using WISH, interacting with the operating system, creating widgets, building your own user interfaces, using Tcl/Tk to interface to legacy programs and systems, creating Web applications with Tcl/Tk, and using Tk with Perl and C. ... Read more

Customer Reviews (6)

Good for fast learning; not so good for reference
I started off with the Welch book but quickly realised that it was not for beginners and switched off to this one. I think for a quick ramp up this book is good enough but you definitely need another book to take you to the next level.

A word of caution/Public service message: Listing 8.5 on page 133 has a wrong analysis. I would have loved to put this in a errata but it doesn't exist. Luckily the said error is about globs which many people don't use anyway.

Need to Learn TCL Quick...
I needed to pick up tcl quickly for a new project of mine, this book got me up to speed in no time, great examples, easy to follow even for a beginner. Using the book as a reference is a bit tough but make sure to purchase "O'reilly's; Tcl/Tk Pocket Reference" thats a great reference for the language.

This book Tcl/Tk in 24hours will teach a whole lot in no time.

Lame Book not worth buying
.

********************************************************

I usually am enthusiatic about the books I review.Unfortunately, this book does not cut it.I chose it because of the high marks it received from other reviewers.

Instead I recommend Pratcal Programming in Tcl and Tk, by Brent B. Welch.Here is a book which give you some value.

If anyone wants to buy this book contact me, I have one for sale.I'll sell it for $5.

Conrad B. Senior

********************************************************

Quick and Practical Introduction
A very good book to get you started programming in Tcl/TK and see some fast results. There is sufficient amount of detail to learn the basics. What I liked most is the way the examples are presented, you are encouragedto experiment and it is great and easy with Tcl/TK. At first I wanted tosee more detailed coverage of the various options, but the book encouragesyou to use the Tcl help files and - a good habit to develop when you getinto more serious programming. The Q&A and excercises help quite a bitwhen you are learning on your own. I have been able to adopt a lot of theirexamples to a demo program for my work.

Not a good book for learning or reference
I bought this book based upon online reviews and I was sorely disappointed with what I received.While the book does step you through the Tcl language it does not lend itself to acting as a reference book when you'retrying to get a project done and need to look things up.

If I could havedone it over again, I would've gone with the O'Reilly book on the sametopic. ... Read more

Product Description
[ncr_tcl_tk]- the object-oriented extension to Tcl/Tk - saves programmers development time. There are currently 150,000 [incer_tcl/tk] users and growing.[incr_tcl/tk] is used for everything from scientific applications, such as flight software for the Mars Pathfinder, to budiness applications, such as stock watching.First to market - there are no other books available on [incr_tcl/tk]."This book will make it easier than ever for people to use [incr_tcl/tk]."This book will make it eaiser than ever for people to use [incr_tcl/tk]" - John Ousterhout, CEO of Scripts and author of the Tcl language.Explains how to write streamlined code, build integration applications and GUIs, and provides real-world examples. ... Read more

Customer Reviews (8)

incomplete but necessary reference
The book treats "incr-tcl/tk from the ground up," as it says. But tcl/tk is very high programming ground to begin with.

Brent Welch's books are outstanding starting points in tcl/tk. Further, I stumbled on a CDROM with the tcl/tk/iWidgets manual pages in html. The CDROM has enabled me to play with iWidgets without wearing out the paper pages of this valued book.

In short, this book SHOULD be supplemented in a hoped for second edition.

Be sure you want a book on the INCR extension of Tck/Tk !
Be sure you know Tcl/Tk and want a book on the INCR extension of the language!

When this book arrived, I found the subtitle "From the Ground Up" was misleading to a Tck/Tk-know-nothing like me. The first two examples in the book were impenetrable on a line-by-line basis, but only because I have no Tcl/Tk background to understand the keywords and parameters. What the examples were about was clear from the good choice of variable/procedure names in the code, but since I don't know and can't find out what "wm", "pack", "deiconify" do exactly, and what parameters they take, that was the end of the book for me.

Had I known (more than?) a few Tcl basics, I may have kept this book. If you already know Tcl/Tk, this book is probably great for going on to the "[incr]" version of the language. I just don't know if the extensions are important yet. My planned use for Tcl is probably on the fringe.

The book itself is a nicely massive 4 lbs (according to my bathroom scale - so give me slack of +/-1 lb at least!) There is no CD-ROM with the book...

This is NOT a book larded with mostly-useless screen shots to bring up the page count. All 746 pages look like they are full of good info, with probably only one diagram for every 25 pages. The text has about a 50:50 mix of code:explanation, there is a huge reference section (appropriate for this kind of book) and a 20-page index. The book measures 7&3/8" wide, 9&1/8" tall, and a nice 2 inches thick.

Browsing the table of contents, the first 13 chapters cover the sort of practical subject matter I'd want to know about AFTER being familiar with Tcl/Tk; the mind-set, orientation, and approaches to using the language to get something done, but certainly NOT from a simple Tcl/Tk syntax and reserved words standpoint. (That's what I wanted, though). The 14th chapter is nearly 1/2 the book and is a programmer's reference for the Iwidgets. Each 5 page (on average) Iwidget treatment looks like JUST the sort of complete and detailed info I'd want. The Iwidgets look like all the sorts of things I'd want if I were developing windowed user applications.

I may buy this book after acquainting myself with Tcl/Tk: browsing the book has interested me in using the [incr] extensions - but only if what vanilla Tcl offers is too rudimentary.

I do NOT agree with the statement on both front and back covers: "Open This Book as a Novice and Finish It as a Pro". I have programmed in most languages for over 30 years, and this book wastes NO TIME going over what a novice needs to know. I'm trading down to an introductory book. But I may come back!

I very much agree with the book's cover when it says: "The Accelerated Track for Professional Programmers", I concur with that view. But "From the Ground Up" and "Open This Book as a Novice..." are simply inappropriate on the cover of this book. The word "lies" comes to mind.

I'm almost tempted to read some web tutorials on Tcl and keep this book, but I can flip pages to review and reference material much faster with hard copy, and probably won't need [incr] extensions for my project.

step by step, never leave you behind....
the author guides you through how to develope object oriented software in Tcl (using [incr Tcl/Tk] extension).

it was well written, and easy to follow. examples are well explained, including why certain things are defined/designed from his perspective.

the book covers OO programming in Tcl and Tk, debugging technique and even integrating [incr Tcl] with C/C++.

the font size and layout is also easy on the eyes and definitely helps towards providing a good read.

Not a great book but it's the best we have on iTcl.
I admit right off that the book is well written but it fails in two ways. As an introduction to object oriented programming it is ok. But for those familiar with oop it is a verbose intro to iTcl and those subtle areas that really need attention don't get it. I would go as far as to say it misleads naive readers on some oop concepts by oversimplifying them. The second failure is that half the book is just a repeat of iWidgets reference material that is already available. What we sorely lack is a useful manual on iWidgets that adds real value. The book could have been 1/4 as thick as it is. The reason I own and use the book is that when it comes to iTcl there really is no alternative. But a better intro to iTcl is found in "Tcl/Tk Tools", written by the creator of iTcl, Mark Harrison. However, that intro is sadly out of date now. I would encourage Chad Smith to "finish" the book by writing a second volume concentrating on the use of exisiting iWidgets and the creation of new iWidgets.

Royal Road to OOP
This book is superb technical writing about a rather abtruse subject. The author anticipates the readers' questions and even the likely error messages when using the online code examples. Beautifully organized,written and edited... it's hard to imagine a better introduction to objectoriented programming. Chad Smith should quit his day job writing code andwrite more books for us like this, perhaps a sequel with 4 or 5 extended[incr Tcl] project examples. ... Read more

Product Description
A practical guide focusing exclusively on Web applications of Tcl/Tk. Like Java, Tcl/Tk enables programmers to create programs that can run independent of graphical hardware or operating systems. This makes it a natural for Web developers. Packed with real-world examples, this book reveals how to write a complete browser in the latest version of Tcl, create GUI components, and use Tcl to interact with Java, JavaScript, and CGI/Perl. It also demonstrates how to write Tcl applets, called "Tclets" and provides plug-ins that can handle these applets. Tcl (Tool Command Language) is a scripting language with its own built-in interpreter that can be used to easily develop applications. Tk is the Tcl toolkit for building graphical interfaces. Companion Web site features all code and Tcl applets from the book. ... Read more

Customer Reviews (2)

More on TCL/TK than web programming
If I had picked up this book for web programming I would have been very disappointed as only the last chapter covers this. Instead I was looking for a book on TCL/Tk 8.0 or later and this acts as a very goodintroduction.All of the sample code is built-up line by line and workedthrough repeatedly; This might get wearying, but it is much clearer thanother books on TCL I have read. You do not need a laptop to work though theexamples when reading the book on a bus either.

Beginner book on TCL/TK - very little web programming
I was very disappointed in this book. The title suggets that the book covers tcl programs for the web. I was expecting sockets, http, ftp, etc.. There is a total of 4 pages that deals with sockets. Some good coverage ontclets but minimal. The vast majority of the book (90%) deals with thevarious widgits in tk and tcl programming constructs. A good book forbeginners to tcl/tk but very little on web development ... Read more

Product Description
Tcl and Tk graphical toolkit are powerful building blocks for creating dynamic Web content and graphical user interfaces--user base is 1 million and growing. Covers all basic Tcl language elements, Tk commands, widgets, and options. Quick, concise, accurate, and portable--ideal for everyday use. "Programmer's Tip" text boxes showcase author expertise and provide recommended approaches to different situations. ... Read more

Customer Reviews (13)

No-nonsense reference
Experienced programmers expect this kind of reference: brief but clear explanations of basics, and all the major language features listed alphabetically. It's the "sensible shoes" of Tcl language guides.

Tcl itself is a scripting and integration language, a little like Perl without string processing, and with syntax almost as simple as Forth. That makes it a fair candidate for running way in the innards of complex tool suites. Like other scripting languages, variables are untyped, and available types form a very short list. And, like other interpreted languages, many of its features border on self-modifying code. For example, runtime generation of variable names comes as easily as array subscripting - which it rather resembles, if you're used C-like syntax - and can serve many of the same purposes. I'm using on-the-fly script generation, a crossover of code and data that Lisp lovers will recognize (but without the mathematical elegance).

I can't think of an application where Tcl would be my tool of choice, given what's available today. But, I don't always get to choose. If you're thrown in at the deep end and don't have time to learn the language you're programming in, you'll want a reference like this one.

-- wiredweird

Tedious Waste Of Time And Money
This book is a dictionary of Tcl/Tk commands. If you are looking for *any* more information than that, good luck. I was forced into consulting this book by a need for information on the Tk geometry managers and configuring various widgets, but got more information from the O'Reilly title 'Perl In A Nutshell', which has a single chapter on Perl/Tk that is of greater use than this entire worthless tome. A waste of time and money.

I use it all the time
When programming with TCL I need a quick reference. This book does the job. I can find whatever it is I'm looking for. If you a programming with TCL and want a reference, consider this title. This book even had info on the "http" package that comes with TCL, this was a big plus when I had to do some work that required that I use the http package.

Mike's review
This is the first book I bought about Tcl/Tk.Why?It was the only one they had at the store I went to.I've since bought others (three to be exact), but this is the one I always go back to.Information on the Tcl and Tk commands is easy to find and each example I've tried works.Which, from my experience with books on programming, is amazing!I highly recommend this book!

Mike

Just what I was looking for...
If you have programmed in other languages (especially Perl) and you want to learn Tcl, then this book is for you.

I tried to use a couple of other Tcl books but they were too basic. I couldn't find good examples that showed the syntax in those books.

This book is mainly a command reference book. So, if you know Perl you can just look up the corresponding Tcl commands which are mostly named the same, and get the Tcl syntax. ... Read more

Product Description
This introduction to Tcl/Tk bridges the gaps between introductions, comprehensive manuals, and collections of scripts that solve particular problems. There are over 200 exercises with solutions for both Unix and Windows platforms.

Tcl/Tk for Programmers introduces high-level Tcl/Tk scripting language to experienced programmers with either Unix or Windows backgrounds. It includes a short introduction to TCP/IP, introductions on writing client-side scripts and GUI interfaces as well as integrating scripts with C/C++. In addition to covering version 8.0/8.0, the book describes the major differences between version 8.0/8.0, 7.6/4.2, and the experimental alpha version 8.1/8.1. Zimmer has extensive knowledge of Tcl/Tk programming and currently runs a consulting and training company based on his experience. ... Read more

Customer Reviews (4)

The best programming book I've ever read
Mind you, as the title suggests, this shouldn't be your very first experience programming.It's not a "learn Tcl in 7 days" book.You want to have some other languages under your belt first. It's aimed at someone who will digest a lot of information fairly quickly.The writing is fun and humorous.The very first chapters are essential, as Zimmer does everything he can to explain the nuts and bolts behind braces, quotes and variable substitutions.He uses these core pieces of Tcl in ways you will likely never encounter in actual Tcl/Tk programs, but serves the purpose of breaking them, soliciting head-scratchingly unintuitive results, etc. so that when you start coding yourself, you wil know to be careful with your syntax-- know what the pitfalls are and avoid them.If you are patient enough to go through all of the exercises, you will have a very strong and solid understanding of this fantastically elegant and programmer-friendly language. The only part I don't like is that the index at the back of the book is too brief.The book partly makes up for this by having 2 more indices used to locate specific functions and procedures.I recommend you also invest in the O'Reilly Nutshell or Pocket Guide books, because this book is more tutorial than reference in nature.

toilet paper
It was useful as toilet paper, but not much else.

only for intermediate/advanced programmers
This book definitely has its pros and cons. The main likable aspect is that Zimmer gets right into the language; no long history or touchy-feely introduction. If you've done some programming and are comfortable withtypical flow-of-control structures, expression syntax, and have done someshell programming on Unix platforms, you will quickly get a handle on Tclwith this book.

However, Zimmer uses some unusual verbiage (eg.,"action families"), and expects the reader to understand quite abit already. Given that the content organization is a little strange, andthat the index is brief, it is difficult to quickly dive in and createuseful scripts.

Lastly, on any given topic, the book covers the basicconcepts then immediately proffers exercises (for which solutions are givenat the back of the chapter). If you work thru this book from start tofinish and do the exercises, you will value this book. Personally, Idespise exercise-based books; I prefer authors who bring the material to mevia explanations and well-documented examples. If I wanted to learnstrictly by doing, I'd download the spec and figure it out for myself.

If you're starting with Tcl start here.
I wish I had this book a year ago.Most other Tcl books are the "How to create a Tk app", type of thing, that gloss over the details that have you pulling your hair out later.This book goes through the detailsof how things work, in detail, with excellent "mini-quizes" thatillustrate all the important concepts.If you program in another languageand need to do work in Tcl, do yourself a favor, get this book and spend aweekend going through it first. ... Read more

Product Description
This title provides programmers with a complete guide to all aspects of this multi-platform language including using the Netscape plug-in, and working with TCL as the first server and client-side CGI application language. Extensive coverage of TCL/Java integration allows you to develop Internet applications easily with the best tool for the job. The CD contains fully functional applications, code and components developed in the book. . ... Read more

Product Description
The Web is rapidly shifting from static sites to dynamic, interactive and animated sites. This book introduces the Tcl/Tk scripting language as a viable Web application development tool. It presents the fundamentals of programming with Tcl/Tk, and equips the reader with applications that take advantage of the Internet environment. The final chapters include advanced applications using the Spynergy Tcl/Tk libraries found on the enclosed CD-ROM, and incorporate PGP signatures. The CD-ROM contains a variety of examples and tools which allow readers either to build on basic applications or use the lessons in the book to build a "weblet" from scratch. Also included on the CD-ROM is the "Ed Tcl Code Editor," an editing and testing application written entirely in Tcl/Tk, which allows web developers to cut, copy, paste, search, and test code merely by pressing a button.

*Special emphasis is placed on secure interactive applications and PGP
*Chapters range from how to create text and graphic animations to how to build a complete web browser in Tcl/Tk
*CD-ROM runs on UNIX/ISO-9660 (all platforms) and Windows, and contains sample tools, programming utilities and sample code, as well as "Ed Tcl Code Editor" ... Read more

Customer Reviews (6)

Better get a Book of Brent Welche instead!
Forget this book. Half of the book consists of a Tcl/Tk introduction, better explanations are found in other books. Tcl/Tk code builds the other half, and Tcl/Tk code examples are available for free on the net. Thetoolbox they use in their examples hides all the real information you wouldneed to understand the examples. But that's not given.

If you really wantto learn about Tcl/Tk refer to the books of Brent Welch. There you willfind a lot of examples and, in case you need more Tcl/Tk source code tolearn something, look at the applications available (f.e. at Scriptics.com)

Good demos
I really liked the example code.It's nice for a change to see really useful example programs, instead of the usual enginerdish foobar stuff.

Excellent introduction to Tcl/Tk
I've read a lot of introductory computer books that have left me after reading with the question "now what?"This book definitely answers that question.The example of the pure Tcl PointCast clone wasabsolutly incredible! The Spynergy Toolkit library makes it surprisinglyeasy to put together these sorts of apps, without much fuss.

Great demonstration of the power of Tcl/Tk
Wow!I had no idea that you could build such a variety of cool applications with the Tcl/Tk language.This book is the best I've seen from the point of view of teaching by example.

Not really explaining anything!
One of those programming language books where the printed source code is used to fill the pages. The authors to not show HOW things work. It's just a collection of well documented Tcl code. Most of the example are based onthe Spynergy Toolbox, which is a rather "exotic" toolbox forTcl/Tk and not at all a Tcl/Tk standard. Half of the book is a Tcl/Tkintroduction. But if you want to learn Tcl/Tk use Brent Welch's book. Thesecond half is nearl ONLY Tcl source. ... Read more

Product Description
8072G-1 Use Tcl/Tk to build the custom network management tools you need. Often, there's no substitute for a custom network management tool-but you can't afford to spend months building one. There's a quick, easy solution: Tcl/Tk scripts. Learn to leverage Tcl/Tk's power and efficiency-from experts who've built successful network management products for Cisco, Digital and 3Com. Discover why Tcl/Tk tools are perfect for troubleshooting, device monitoring, inventory, configuration, and many other network management applications. Then build five real-world applications to use right away, learning concepts and routines you'll reuse constantly:*Response time monitoring *Network discovery *IP path tracing/diagnostics *Web-based status monitoring *RMONv2 configurationLearn proven techniques for Web-enabling your network management applications-and for building tools that are extensible and easy to modify. Carefully annotated code and extensive screen captures show exactly what to expect. An accompanying Web site includes downloadable source code, new tips and insights, and much more.With Building Network Management Tools with Tcl/Tk, you can deploy the tools you really need-when you need them. ... Read more

Customer Reviews (5)

Can't get sample source code
I failed to get the example source codes listed in the book by following the exact instructions of the book. In addition, I can't contact auther for this.

Unsupported book:(
The accompanying web site is unreachable. Most examples are based on a commercial package (TicleMan)

Very good book, Examples cannot be reached
I believe this book deserves a 5 stars rating. But you cannot get the examples with the provided username and password. This means wasting time which avoiding it is the reason for buying this book from the beginning.

This is the definitive reference on SNMP and TCL/Tk.
I definitely wish that every technical book was as well researched and written as this one is. If you're trying to build a network management application using TCL/Tk, this book is invaluable. Watch out for twothings, however: The Scotty examples are using a pre-release 3.0 version ofTNM, while most of us in the real world are using the non-commercial 2.1.9version, so the examples don't work exactly as shown.Also, the websitethat the book directs you to doesn't have all of the code discussed in thebook.Despite these few flaws, it's still worth five stars in my opinion.

Perfect resource for creating Tcl/Tk GUI's to manage a net!
This book offers many Tcl examples to show network discovery, status monitoring, etc.Ifyou are looking to build concise, custom mgmt tools to meet your specific needs, Tcl/Tk and this book will get you well on your way. ... Read more

Product Description
Any program worth its salt uses operating system services.Even a simple program, if practical, reads input and produces output.And,most applications have more complex needs.They need to find out the time, use the network, or start and communicate with other processes. Systems programming really means nothing more than writing software that uses these operating system services.UNIX Systems Programming for SVR4 presents the nitty-gritty detailson how UNIX interacts with applications.If you're writing an applicationfrom scratch, or if you're porting an application to any System V.4 platform,you need this book.It offers a complete, thorough explanation of all UNIXsystem calls and library routines related to systems programming, workingwith I/O, files and directories, processing multiple input streams, fileand record locking, and memory-mapped files.You'll also learn aboutreading, printing, and setting the system time and date, determining whois logged in, and setting user and group ID.The book also shows you how to change system configuration parameters forresource limits and how to create processes, job control, and signal handling. Also discusses interprocess communication, serial line characteristics,network programming with Berkeley sockets, Transport Layer Interface (TLI),and the data link provider interface. ... Read more

Customer Reviews (6)

Also a good book on C
This book isn't just a handy reference for programming in C in the UNIX environment; it's a useful reference for any C programmer.For example, the discussion of file I/O is very clear.

Outstanding!
In my opinion, this is the best book on UNIX programming I have seen.If you already know C and want to learn how to program on the UNIX os, this is the book to get.This is what taught me.I usually always have this book with me.I even like the color!

Essential C reference, but who knew?
If there ever was a book that was badly advertised, this one is it. If we're to believe the cover and even the reviews on Amazon, it's just another book on Unix, when actually it's an essential Unix System V Clibraries reference for C programmers. I haven't found anything remotelysimilar out there. I only bought it after flipping through the pages in abookstore. It covers everything from file I/O through IPC. It contains tonsof code that clearly show how to use each function. As it's a little dated,It doesn't cover pthreads or IPV6, but hopefully the author will make asecond edition soon...and make sure that C programmers know that this bookis what they're looking for!

A jump-start for system programming for Unix.
This book is written in a very easy and understandable way. It explains main concepts, system calls and their parameters and how to use them. It lays an excellent ground for a quick start in UNIX systems programming andprepares for more in-depth material like books by R. Stevens. I would saythat this book is a must-read for all starters.

Excellent book
This book gives an excellent introduction tosystems programming in unix. Within a coupleof weeks of buying this book, I was able todesign and implement a multi-process clientserver (socket based) application from scratch.The author also discusses the common C libraryfunctions used and the caveats there of. (forinstance, the gets() function is a dangerousone!) Although I program a lot in windows NT,I still find this book to be a good reference,especially when porting applications from unixto NT. One thing that I wish the book had is adiscussion on remote procedure calls (RPC). ... Read more

Product Description
The leading book in its field, this guide focuses on the design, development and coding of network software under the UNIX operating system. Provides over 15,000 lines of C code with descriptions of how and why a given solution is achieved. For programmers seeking an indepth tutorial on sockets, transport level interface (TLI), interprocess communications (IPC) facilities under System V and BSD UNIX.Amazon.com Review
Focuses on design, development, and coding of networking softwareunder the UNIX operating system. Begins by showing that a fundamentalbasic for networking programming is interprocess communication (IPC),and a requisite for understanding IPC is a knowledge of whatconstitutes a process. Throughout, the text provides both descriptionand examples of how and why a particular solution is implemented. ... Read more

Customer Reviews (15)

One of the best books I've ever read
This book must be by far one of the most valuable books I have ever read. I learned to love Unix/C programming from it and I have treasured the knowledge I have gained from it ever since. Mr.Stevens has passed away but this book holds some wonderful memories and discoveries for me.

Classic work - but in series need of updates as time goes on
I cannot fathom a guess as to how many times the books in this series have saved my in project work over the years.The only drawback with this series is that some publisher should endeavor to keep them up to date.Serious Unix system programmers must have copies of the complete series.

A Unix Bible
I have been actively involved in computer software/hardware for close to 20 years and have purchased probably 200+ books in this time period. Over 75% I wish I hadn't purchased. This book is probably in my top 10 however.

This book is what's called a "Bible". It's an authoritive reference on Unix networking and communications (ipc/rpc) and much else. I equate it to the Kernighan & Ritchie C book, etc.

I wouldn't recommend this book to someone new to computers, but if you have a few years under your belt, or are an eager-beaver then go ahead...you won't regret your purchase.

The author uses a simple client/server program example (a simple file server) and then goes through several iterations/revisions, each using a different IPC mechanism to accomplish same task. A great technique for exploring new concepts...tie them all to a single program design with the program evolving to use different APIs/IPC mechanisms.

A "must-have" classic programming text
Don't let the title fool you - this book is more about writingrobust applications in UNIX than mere network programming.
In his trademark crisp and to-the-point style, Tanenbaum describes UNIX from the C programmer's point of view. The book groups system calls by domain (file I/O, IPC etc) and illustrates different usage scenarios. This is one of few texts that explain the *why* aspect of system calls, not just the *how*. After reading this book, you will have gained insight on improving your current programming project, and understand UNIX inside-out.

Astonishing and Readable! Simply let knowledge flow in you!
Okay, this is the story. I have not bought this book, but got it from a university library, for a short term of a week. It is an amazing book, Richards simply is a magician, when ever it comes to displaying and explaining data. There are 2 kind of books, one that you read 50 pages of, and start randomly select pages to read out of it, and one that you read fully, continuesly, and never noticed you have spent a whole day reading it. Richards casts a spell on you with his books, they are magically clear, and vastly informative so that you will surely understand with every meaning of that word!. This is the second kind of a book! A MUST on every shelf, unfortunatly i am still desperately looking for this book!. For the "data" in it: Robust explanation of UNIX, Richards goes from the OS view and dives deeply into the internals, providing vast and clear explanations for _everything_. Throw all other books away, this is THE book. ... Read more

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

Customer Reviews (6)

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

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

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

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

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

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

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

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

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

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

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

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

Product Description
Presents a comprehensive guide to every form of IPC, including message passing, synchronization, shared memory, & Remote Procedure Calls (RPC). Text contains extensive new source code - all carefully optimized & available on the Web.DLC: Unix (Computer file).Amazon.com Review
The first volume of Unix Network Programming, Networking APIs: Sockets andXTI covers just about everything you need to know to get yourapplications to talk to other computers on a network. In this secondvolume, W. Richard Stevens discusses what you need to know to get yourapplications to talk to other applications running on yourcomputer. There's a big difference, and Stevens covers it well.

Stevens introduces the reader to the internal structures of Posixinterprocess communication (IPC) and System V (SysV) IPC; pipes andfirst in, first outs (FIFOs); message queues; how to lock and unlockfiles and records; semaphores; shared memory; and remote procedurecalls (RPCs). He explains the difference between the Posix and SysVimplementations of semaphores, message queues, and sharedmemory. There are also plenty of notes and examples for the reader.

This book is invaluable for programmers because it explains all ofthose little "gotchas" that always seem to pop up. In addition, theexplanations of the differences between Posix IPC and SysV IPC reallyhelp readers decide which version they'd like to use for theirapplications. --Doug Beaver ... Read more

Customer Reviews (13)

Great BOOK
Just a great knowledge pot.Great book and there are others in the series.Recommended.

purchased on Sep 23, not received yet
I ordered the book on Sep 23. Today is Oct. 28, I haven't received the book yet. When will I have it? Are you cheating me to get my money and give me nothing?

If you want to program in Linux you need this book.
Programming UNIX or Linux networks is a piece of cake with these books. You need the set, Vol 1 & 2.

As a professional programmer of 20 years I use the book as a refernce for all my new programs. I have used the books to break into the world of VoIP and audio CODEC network programming.

Classic work - but in series need of updates as time goes on
I cannot fathom a guess as to how many times the books in this series have saved my in project work over the years.The only drawback with this series is that some publisher should endeavor to keep them up to date.Serious Unix system programmers must have copies of the complete series.

The real power of UNIX is in communication
The real power of UNIX or any application for that matter is in interprocess communication. I found early on that to accomplish any large project would require the cooperation of interprocess communication. Now I find that simple administration skills also require a knolage of this interprocess communication.

My first foray into the field was to use semaphores to flag processes to run at the proper time. Later I needed to use pipes for a front-end in communication to SNA. Again I found IPC's could help inform and control processes that were in canned packages and not accessible any other way. The list of useful tools can go on and on. I also had to find the NT equivalent as it became popular.

UNIX is still out there in many forms and if one is to survive in the field an understanding of interprocess communications is imperative.

The Abbreviated Table of Contents:
Part 1. Introduction
1. Introduction
2. POSIX IPC
3. System V IPC
Part 2. Message Passing
4. Pipes and FIFOs
5. Posix Message Queues
6. System V Message Queues
Part 3. Synchronization
7. Mutexes and Condition Variables
8. Read-Write Locks
9. Record Locking
10. POSIX Semaphores
11. System V Semaphores
Part 4. Shared Memory
12. Shared Memory Introduction
13. POSIX Shared Memory
14. System V Shared Memory
Part 5. Remote Procedure Calls
15. Doors
16. Sun RPC
Epilogue
Appendix A. Performance Measurements
Appendix B. Threads Primer
Appendix C. Miscellaneous Source Code
Appendix D. Solutions to Selected Exercises
Bibliography
Index

One final note is that with systems dispersed globally Remote Procedures Calls are taking precedence in Interprocess communications.
... Read more

Product Description
Designed as one of the first true textbooks on how to use the UNIX operating system and suitable for a wide variety of UNIX-based courses, UNIX and Shell Programming goes beyond providing a reference of commands to offer a guide to basic commands and shell programming. Forouzan/Gilberg begin by introducing students to basic commands and tools of the powerful UNIX operating system. The authors then present simple scriptwriting concepts, and cover all material required for understanding shells (e.g., Regular Expressions, grep, sed, and awk) before introducing material on the Korn, C, and Bourne shells. Throughout, in-text learning aids encourage active learning and rich visuals support concept presentation. For example, sessions use color so students can easily distinguish user input from computer output. In addition, illustrative figures help student visualize what the command is doing.Each chapter concludes with problems, including lab sessions where students work on the computer and complete sessions step-by-step.This approach has proven to be successful when teaching this material in the classroom. ... Read more

Customer Reviews (3)

Nice Visuals, Way To Lenghty
I'm actually taking Forouzan's class at DeAnza college in Cupertino. He's a great guy, but like his book he goes explains everything too much. What should be a 30min talk about grep, he explains in 2 hours.

This book is perfect who have a hard time understanding computers. For the more advanced students I suggest a smaller book with the basic commands the their attributes.

Superbly Well Written
Superbly well written book on UNIX shell scripting.Crystal clear explanations and excellent examples.Make it part of your library.

One of the better books
Really helps in taking me out of many tough spot in writing awk and sed scripts. I think this is a really good book. ... Read more

Product Description
This completely updated and revised version of the bestselling original describes how to develop interactive applications for the X Window System using the Motif user interface toolkit. It shows how to use the facilities of all three Motif libraries--Xlib, Xt Intrinsics, and visual components. ... Read more

Customer Reviews (5)

great intro
I picked up a copy of this book in an attempt to familiarize myself with X/motif.This book made things very clear for me.After the first 2 chapters, I had a really good handle on the differences between X, Xt, and Motif.I also used chapter 5 heavily (Manager Widgets), which gives a great rundown on frames, forms, bulletin boards, and general dialog window layouts.I can recommend this book eagerly to anyone wanting to learn about X before jumping into X code.This edition was published in 1994, but it all still seemed relevant.

Just like new
Well, I never knew that I can get used books also with almost like new standards. I am not able to find out any kind of mark or torn pages in the book on the first look. It was awesome. Book was delivered on time.
And moreover the used book like new book in such a low cost!!! What else one need??

the best there is
I learned X-Windows programming from this many years ago. Please bear with me as I set up the scenario here.As an independent consultant, I was in a situation where--in order to win a juicy federal contract--I had to represent that I was sufficiently expert in X-Windows to (a) build a toolkit of custom widgets; (b) build tools that allowed users to choose from a set of predefined "color palettes" such that (b-i) only certain classes (let's call them "Brand Q") of applications followed those palettes, other applications following the standard system palette, and (b-ii) the palettes interacted with the window manager such that, when the last Brand Q application was iconified, the standard system palette was restored, yet, as soon as any Brand Q application was deiconified, the user's chosen palette was reinstantiated;and (c) build tools that enabled a Certified Professional Ergonomist, or CPE (!), to experiment with widget appearances and parameters so as to craft an optimal set of palettes and then represent those palettes in such a way that X applications would properly follow what was visually intended. Oh, on top of all that, it had to interact with a visual GUI builder called UIM/X that implemented a whole set of "shadow widgets" that paralleled Motif widgets and let you edit their properties--rather like a Java "bean editor" one might find useful nowadays.

Well, I had to learn enough to write a thick, highly literate design document within a couple of weeks, and then go out and build some 40K lines' worth of applications code (in C, of course) and 15K lines' worth of "system" code (I'd define as "systems code" software that (a) interacts with the window manager vis-a-vis iconification and deiconification semantics; (b) communicates complex data structures via interning atoms with the X server; (c) tortures strange color mapping behaviors from an outdated NCR monitor that could only physically display sixteen colors at a time [thus having to rely on dithering and related visual effects to achieve other "colors"] and offers tools for related colormap management tasks) within a handful of months.

Now, I'm not complaining about the level of effort--given the six-figure consulting fee that lay at the end of the rainbow. But without Young's outstanding book, I'd have been dead in the water. Oh, of course I had access to the O'Reilly series of seven or eight books--which were occasionally useful for stealing a handy application that could quickly be incrementally modified (e.g., I needed quick code for a dialogue box managing three green buttons, and one of the O'Reilly books illustrated the code for a dialogue box sporting four yellow buttons). But Young taught me enough about X that I was soon empowered to write my own functions to populate recursive pull-down menus; to write the internals for a widget that borrowed functionality from two other widgets and used cutesy memory management tricks (akin to mainframe-lingo "lookaside buffers") that let me sequentially stack up their respective resources; and to learn how to take advantage of some interesting internals facts, e.g., that the XmN family of symbolic constants are defined as strings identical to their names (a la #define foo #foo).

Bravo, Mr. Young! You taught me much, and you taught me well.

Excellent Introduction to Motif programming
This well written book, with numerous coded examples (that work!) is one of the best computer reference book I've encountered. Although it has not been updated to included Motif 2.1, most applications are still being written in Motif 1.2 anyway. It also includes the necessary Xt and X11 background to write GUIs. I went from zero experience with windows programming to writing full featured X-windows applications solely with the aid of this text and elementary knowledge of C. The author, who worked at Silicon Graphics, went on to write the Open Inventor library (which unfortunately is in C++). Great book!

One of the best for Xt/Motif Programming
Once upon a time, when I moved from Windows programming environment to X-Windows.. I found things were so diffiult for me.

Lucky me, one day I went to the library and found this book. It helped me to get start with Xprogramming in s considerable short time. The step of this book is quiteeasy to follow, and not difficult to understand. At least it made X morefriendly to me. Although it was Japanese edition and my Japanese isn't thatgood. (And I will buy the English edition soon).

If you want to programin X, this one is a must, Along O'Reilly X Reference Series (which I thinkis the best of X-Ref). ... Read more

Product Description

This book explains in a clear and coherent manner how Unix works, how to understand existing Unix programs, and how to design and create new Unix programs. The book is organized by subsystem, each presented in visual terms and explained using vivid metaphors. It breaks the information into manageable parts that can be presented, explained, and mastered. By using case studies and an extremely reader-friendly manner to illustrate complex ideas and concepts, the book covers the basics of systems programming, users, files and manuals, how to read a directory, using 1S, writing PWD, studying STTY, writing a video game, studying SH, environment and shell variables, I/O redirection and pipes, servers and sockets, writing a web server, license servers, and concurrent functions. For Unix system administrators and programmers, network programmers, and others who have used other operating systems and need to learn Unix programming to expand their skill sets.

Customer Reviews (15)

Very Informative
I find this book to be very informative and complete. You could read this book and understand unix system programming, you may not even need to take a course. It is very thorough with lots of programming exercises per chapter.

Outstanding introduction to Unix systems programming
I bought this book as a quick introduction to the world of UNIX/Linux systems programming. Having had extensive prior experience with the C programming language and application development on other platforms (DOS, OS/2, AS/400), I read the book without actually trying out the sample code or programming exercises.My goal was to get a solid feel for the basic concepts of Unix systems programming as quickly as possible, in order to move on to more advanced Linux topics (assembly programming, kernel and device driver development, implementation of the Linux TCP/IP stack) covered in other books. I found this book to be exceptionally clear and well written and ideally suited for the purpose.

The book requires intermediate knowledge of C and some basic computing skills, but otherwise makes very few assumptions about the reader.Concepts are introduced gradually, and the exceptionally clear diagrams, analogies, case studies and sample programs make each chapter a pleasure to digest and learn from.In order to avoid overwhelming the reader, advanced details are moved out of the main flow of the text, and into the exercises at the end of each chapter.

Each chapter is structured in a similar manner.A small programming project is introduced as the goal of each chapter.Each is appropriately chosen so that the systems programming concepts that are to be the subject of the chapter are key to the solution.The author then guides the reader along the path by asking and answering the questions "What does it do?", "How does it work?", and "How can I write my own version?".The author has a knack for anticipating the types of questions that are likely to be in the reader's mind at the appropriate moments, and helps the reader along with helpful pointers and analogies.This approach is very effective, and while not as detailed and complete as that of W. Richard Stevens (Advanced Programming in the UNIX Environment), it is certainly more readable and easier to digest.

Overall, an exceptional introduction to Unix/Linux systems programming and highly recommended.

question in example code, still 5 stars
I have read more than half of the book. I like the material the book covers and the way of teaching by exemples.
Most other books focus on the features of the Unix system.

However I have minor questions:
1. There are typographical errors in exemple code.
2. I do not like function tty_mode(int how) in chapter 6.
it seems trivial and unnecessry and the static variable inside
the function seems questionable style.
I wonder why these obvious things happened in such a good book.

An excellent course through Unix and Linux with copious code and examples.
Unix has had the luxury of being one of the most documented operating systems in history. Many books have been dedicated to documenting the internals of Unix and Unix-like systems and some have risen to the ranks of classic texts regarded by all as necessary to understanding the inner workings of Unix. Understanding Unix®/Linux Programming would be in excellent company with these books. The book contains a copious amount of code and clear, diagramed explanations describing the processes transpiring in the machine.

Understanding Unix®/Linux Programming is designed to be used in an operating systems course with programmers fluent in C. Fortunately, though, the book can be used outside of the classroom if the reader does not mind an occasional open-ended questions with no included answers. The book may seem light on pages (530 including index), but the author should get an award for jamming so much useful explanation and helpful (and complete) code. The format of each chapter is familiar to most textbooks, with an introduction to the task at hand, explanations and examples, a summary, a list of explorations to further understand the topics presented, and a set of programming exercises. The exercises are creative and directly relate to the presented code.They're also (dare I say it?) fun. I'm not saying they'll replace crossword puzzles, but they do present creative or obvious challenges to the reader. (Like handling when a user types 'exit' from a shell, or blinking the text in an ncurses application).

The book includes topics on file I/O, device I/O, timers, process management, stream and datagram sockets, POSIX threads, file systems, the terminal driver, signals pipes, network programming and semaphores. A typical chapter will introduce an operating system concept (file systems and directories, for instance) and will briefly describe the current Unix command for working with that concept (pwd for determining the present working directory, or ls for listing the contents of a directory, and so forth). The author then proceeds to give a detailed description of what the operating system does to run the command. In the chapter on processes and programs, the author describes what processes are and how to use the ps command. Next the author describes how to fork child processes, and wait for them. This leads to the 'prompting shell', which is a simple, yet functional shell environment. Now some books would leave this exercise after creating a semi-functional shell, but the author presses on and in the next chapter creates 'small-shell' which is an interactive shell with a minimal scripting langauge and variable support. All of this in the span of 71 pages, with plenty of examples, full code listings, diagrams, and problem sets.

Understanding Unix®/Linux Programming takes advantage of the inquisitive nature of coders by presenting commands and command squences we all take for granted, and turning them into "how do they work" learning experiences. Anyone who has ever stopped to think why certain things work the way they do in Unix (or work at all) will find this book immensely helpful in sating that curiousity. Students who are assigned this textbook for a class should thank their teacher for choosing a genuinely useful text from which to read. I can't help but be jealous of students who will use this book for their classes. That jealousy is short-lived though, as anyone who wants an excellent resource for learning Unix programming will benefit from picking up this book. Kudos to the author for crafting not only an exceptionally easy to read and thourough book, but for taking the complex machinations of Unix and making them simple and accessible for all coders.

Easy to understand
It goes right to the point and it's easy too understand. One of the very few books out there that really shows what system programming is all about.Great samples too. ... Read more

Product Description
The bestselling guide to assembly language-now updated and expanded to include coverage of Linux

This new edition of the bestselling guide to assembly programming now covers DOS and Linux! The Second Edition begins with a highly accessible overview of the internal operations of the Intel-based PC and systematically covers all the steps involved in writing, testing, and debugging assembly programs.

Expert author Jeff Duntemann then presents working example programs for both the DOS and Linux operating systems using the popular free assembler NASM. He also includes valuable information on how to use procedures and macros, plus rare explanations of assembly-level coding for Linux, all of which combine to offer a comprehensive look at the complexities of assembly programming for Intel processors.

Providing you with the foundation to create executable assembly language programs, this book:
* Explains how to use NASM-IDE, a simple program editor and assembly-oriented development environment
* Details the most used elements of the 86-family instruction set
* Teaches about DEBUG, the single most useful tool you have as an assembly language programmer
* Examines the operations that machine instructions force the CPU to perform
* Discusses the process of memory addressing
* Covers coding for Linux

The CD-ROM includes:
* Net-Wide Assembler (NASM) for both DOS and Linux
* NASM-IDE, a command shell and code editor for DOS
* ALINK, a free linker for DOS programming
* All program code examples from the book ... Read more

Customer Reviews (49)

Brilliant Book
This is a book I would highly recommend, and already have recommended, to anyone with an interest in what goes on under the hood of computers.It's written very clearly, starts at the very begining and assumes nothing.Having said that, if you have some knowledge you won't mind reading through the bits you already know because the book is very humerous and enjoyable to read.Definitely the best text book I have read in a long time.

Excellent Beginner Assembly Language Book
I found this book to be very good and although I am using FreeDos 1.0 it is accurate all the way. As Free Dos is a clone of MSDOS you get all the
benefits from the book, like being able to access video memory directly, use the BIOS and DOS interrupts, and learn how to program in Assembly Language. Check out FreeDos org if you are a DOS fan.

I recommend this book for beginning Assembly Language programmers.

A Dissapointment
I started a personal campaign to teach myself assembly language, and searched out books that might help.I bought this book because I own a number of "Step-By-Step" books and the blurb sounded good.Unfortunatly, it turned out to be a dissapointment.

The author prides himself on the fact that he uses an "unusual" method to teach a hard subject, and equally proud that he will not do a "complete" job.And then proceeds to work on chapter after chapter of thin analogy without actually getting to real assembly programming.Now I'm all for "unusual" methods of teaching, but only when they actually work.Reading this book left me more confused than ever.

And of course, to top it off, it's about 10 years old.

I really hate to spend more time on this book, but I wanted to express at least a little bit of my opinion.If I would recommend a book, this other one is worth the money.I even found out that ASU uses it as a textbook, and it's cheaper on amazon.

Assembly Language for Intel-Based Computers (5th Edition)

Additionally, I'd do a google search for winasm, radasm and masm32.All three have wonderful forums to help people learn how to create assembly programs.

THIS BOOK SHOULD BE TITLE "PRE-ASSEMBLY LANGUAGE" !!!
This book is a MUST for anyone taking Assembly Language in a computer science class. Most books on assembly language leave out some VERY important information. Most programming languages are basically the same and require the same logic to use. There is a an important difference between assembly language and other languages like C or Java.

Just like a procedural language like C and an object-oriented languages like C++ or Small Talk requires a difference thought process, so does Assembly Language versus C++ or C#. Jeff does a masterful and humorous job of bridging that gap.

This book shouldn'tbe titled "Assembly Language Step by Step" it should be called "Pre-Assembly Language." The book actually teaches very little Assembly Language, instead, it teaches foundational corner stones such as memory models, CPU function, memory access, binary and hexadecimal numbering systems, and registers. These things are generally glossed over in most text books, yet end up being the most important part. Jeff realized this flaw in other books and wrote this classic. The time to get this book is a semester BEFORE you take a class in Assembly Language, THEN that class in Assembly Language will make more sense. Especially if your going to learn Assembly Language on Intel's 80x86 architecture.

If you're going to learn MIPS or RISC processor assembly language, I'd still recommend Jeff's book. But, I'd also get "SPARC Architecture, Assembly Language Programming, & C" by Richard P. Paul. Richard does a great job like Jeff, but orients his text toward RISC computers.

I HAVE A COUPLE OF WARNINGS: Jeff recommends "Mastering Turbo Assembler" by Tom Swan as the next step. This recommendation is seriously out of date. You can't by Borland Turbo-Assembler new anymore, and the book deals with mostly 16-bit code. Instead, you should get "Assembly Language for Intel-Based Computers" by Kip Irving. This text is up to date with 32-bit code.

Jeff also recommends a book by Michael Abrash. Though Mike's "Black Book" was a great text, it's out of date. I'd recommend that instead you buy "Code Optimization: Effective Memory Usage" by Kris Kaspersky since it's more up to date..

IMPORTANT TO PURCHASERS: Jeff's book "Assembly Language Step by Step" comes with a disk with NASM and programs examples. Unfortunately, they're "READ-ONLY" when you copy them from the disk to the hard drive. You have to change the attribute on every single file to get the program to work. Still NASM and the NASM-IDE are a great addition to the book. If you remove the "READ-ONLY" attribute, you should have no problem.

I hope Jeff will come out with a Third edition to this classic. "Assembly Language Step by Step" should be required as a prerequisite to any Assembly Language class.

First 150 pages rambling, without a hint on the real thing.
At page 151, author said "That's why I began at the real beginning, and took 150 pages to get to where the other guys start."

That is really true, 150 pages wasted!!!

The author is trying to be funny, but actually made it look even worse.
If you are interested in assembly language, there are several online tutorials which are actually much better than this book. ... Read more