Customer Reviews

Practical Programming in Tcl and Tk (4th Edition)

5 star:		(16)
4 star:		(9)
3 star:		(8)
2 star:		(3)
1 star:		(8)

 

 

A comprehensive, systematic guide to practical usage of Tcl/Tkup to version 8.2. Since we have now 8.3 already one needs to checkthe site to see the latest improvements of Tcl. This book constantly helps me to do daily tasks in Tcl. It's a tutorial and a reference. Still I like to mention the book "Effective Tcl/Tk Programming" by Harison / McLennan, which goes much further in tutoring the GUI things. And there is also a handy refernece called "Tcl/Tk, Programmer's Reference" by C.Nelson which fits better onto the desk, if that's an issue. The very old book of Ousterhout himself, which was really great, is now completely outdated.

I got interested in Tcl when a friend of mine had presented me with the Expect application and all the wonderfull things it can do for a sysadmin. Since knowledge of Tcl is required for Expect, I set off looking for a book on the topic... and having read the lines "for beginners and expirienced programmers alike" I thought I hit the target. But what a disapointment...
First of all, most books for beginners follow certain format which is not the case with this book. Nothing like "here's how to declare variables", "variables are typeless", "here's how procedures/functions are done", "here's what sets Tcl apart from other languages" or "how to do those things that other languages cannot" that other books for beginners so often cover. I had to look online for the line that starts off the freshly written Tcl script... and this is for beginners?!
From skimming over Tcl implementations on different platforms (I guess that covered the beginner's part) authors dwelve straight into the HTML processing by Tcl (as in "hey Tcl programmers, here's how to do web pages!") which only adds to confusion. It doesn't stop there though... Tcl is said to be a glue language that puts different blocks together, but how come that passing commands to the system from the Tcl script isn't covered? Yes, there are dedicated commands for cruising through the directory tree, creating/removing/deleting files, but is that all?! Linux has a rich arsenal of commannds, many of which go beyond those tasks... and you cannot pass them from a Tcl script? Where's the glue then...
Same confusing format is followed in the Tk part, except for the canonnical "Hello World" example (straightforward "type it in- here's how it works" breakdown) the rest is off the beginner's path. How to clip a Tcl procedure to a Tk button? Nope, that's not shown- but geometry managers examples plenty abound.
Examples are incomplete, explanations vague and I often caught myself reading same line several times trying to understand the point that author tries to make.
As for my reason for learning Tcl, the Expect application- it is MENTIONED on couple of paragraphs that end with a web address. Although it may be the shiniest example of Tcl's power, it is not even skimmed over...
The content offered doesn't justify the price tag for a beginner's book. If you're a beginner you'd be better off working through the online tutorial at tcl.tk page. It is not only money that you'll save...

I need to learn Tcl because Cisco is starting to use it on their network devices and I need some of the functionality that it provides. I read some on-line tutorials that helped, but thought that I could use a good book to really get up to speed.

I was excited when this book arrived.... Until I start reading it..

Long story short, this book may be good for experienced programmers, but it is not good for the novice. I have programmed before, the usual stuff, I took a C/C++ class or two and made a few small programs. Still, the first chapter "Tcl Fundamentals" had me overwhelmed within about a page and a half.

I consider myself somewhat technical and usually get through some fairly technical book, but this one is a very hard read.

This is not the book to start learning Tcl/Tk. Its a fantastic reference guide. The sample code in the book is clearly not beginners material. If you're writing stuff in Tcl/Tk, this book is probably the only book you will need for reference.

This is one of a small number of Tcl books that I keep handy at all times. I wear two hats with regards to Tcl - one, a site administrator supporting quite a number of Tcl programmers (both classically trained as well as programmers who have learned to make their 'day jobs' doable); the other hat, as one of the comp.lang.tcl Usenet group FAQ maintainers. I find that while there are several dozen books on Tcl, all of which are excellent, I turn to Practical Programming quite frequently for its code examples as well as the appendices discussing the differences between versions.

While there may be those who, out of ignorance or just contrariness, dump on Tcl regarding its syntax, etc. several facts are in doubt in my mind.

1. Tcl is freely available code which can be used as the basis of any reasonable project that needs done.

2. The Tcl community is much more open to newcomers than the other 2-3 dozen 'more recent' languages that I use.

3. The Tcl publishing field continues to show that it is a viable business.

I have to admit my disappointment with this book. I had high expectations about it before I started reading through it. Once I did, I quickly started to find out that the book is not easily readable. Frequently, you will find yourself needing to read one sentense more than once in order to understand what the author wanted to convey. The author could have used a simpler way to phrase his explanations. I wonder why he chose to make things seem dry, rough, and always ambiguous. You will find yourself making very slow progress and feeling like you are not grasping alot of info, or at least not comfortable with the info you got.

First, let me preface my review by saying that I am a professional C programmer, with a background in Perl and Sed/Awk, so I've been around the block a couple of times in terms of both structured programming languages and scripting languages. This is my first exposure to Tcl, and I must say I am rather disappointed.

This book does a terrible job in introducing the language in a structured, straightforward and reasonable fashion. The sparse examples included are oftentimes not explained in the text, leaving the reader scratching their head trying to figure out why the syntax gives the results that it does. The index is very spotty, leaving out reference to pages where important topics are discussed at length. There is no overall command or syntax reference page, so you'e constantly flipping through the book trying to find where a particular command is defined.

The CD included in the purchase price has got to be the most user-unfriendly collection of different versions of Tcl for different operating systems ever assembled. There's no installation program, so the reader is left trying to figure out what to put where on their computer. The "Getting Started" chapter in the text is supposed to guide you through this process, but because it has to deal with disparate systems and versions, is vague and generally unhelpful. Since Tcl is free anyway, and you're not likely to be using it without a computer that is connected to the Internet, why not just point the reader to the appropriate sites on the Web to download the latest versions of Tcl and Tk?

I wish I could say something positive about this book, but I haven't really found it yet. I think that it might actually contain some good practical information for more advanced users of Tcl, but for the beginner this book is a joke.

I had picked this book up to learn TCL to take over a fairly simple TCL code base at work. As a person that is familiar with scripting and programming languages, I found this book hard to understand.

Specifically, example (8-4) is suppose to show an example for passing arrays by name. However, the example is quite cryptic as it uses a variable named array on the same line that it also uses the array TCL command. This causes the example to be fairly obfuscated and hard to understand.

In the first chapter they list the built-in math functions but give very little background on them. They fail to mention that the ceil function actually returns a floating point number. In the index for ceil they even state "next highest integer," which is incorrect.

I have not been impressed by this book for learning and understanding TCL and would not recommend it to colleagues. I can't comment on the TK section of the book, I'm hoping the book is better for learning TK.

I expected from a book praised and priced so high to deliver on
promise. Unfortunately I can't say this is the case with
"Practical Programming in Tcl and Tk (4th Edition) " . Yes, it
shines through every page that the author(s) who wrote it knows the
language in and out; only that unfortunately he (they) failed in
presenting this knowledge in a digestable form.
I am not new to programming and I would see and say it here if the book was written for advanced readers only, but no, the book is just plain cryptic. You will have to read over and over the same example and
explaining it text to MAY be get to the meaning.
The main reason I still bought it is that it was the only more or less
up-to-date book about the language. But now even this reason could be dismissed
- on O'Reilly in June 2009 appeared new edition of
"Tcl and the Tk Toolkit, Second Edition " By John K. Ousterhout; Ken Jones as Rough Cuts version, I am now reading it and rediscovering the
simplicity of this language . Chances are good it will be available
some day as printed book as well.

I am not too impressed with this book. A beginner needs to have useage examples, since a quote, bracket, etc here or there can make a big difference. Welch's book does not give good useage examples on more than one topic. For example, in describing the clock statement, There is an extensive table on formatting options, but not one example on how to use the keywords. Another example is the use of the test command to check two strings in a loop control statement. On several occasions, I have wasted time just hacking around, changing placements of things, putting in extra brackets, etc. in order to find the exact sequence that works.