3 comments about Simply Visual Basic 2005 (2nd Edition).

1. After all the hype about Deitel books I was really looking forwards to reading this book. If you are learning VB at home on your own then this book is a waste of time. This is a college exercise book. There are a lot of examples to practice on at the end of each chapter but there are no answers. The authors assume you have a tutor to fall back on. In fact, you have to be a tutor to get the answers. This makes about a third of the book useless for people who are learning at home on their own. The authors have perfected the art of making rather simple programming concept into very long winded confusing concepts. I've read other VB books that explain the same concepts in a few paragraphs, not several pages like this book does. For a book of this size there are not really many computer concepts explained.
   The only thing I liked about this book was that it had colour screen shots. There are several other good VB books out there for beginners that cost a third of this, are half the size and will teach you many more programming concepts than this book.
   Unless you are on a college course that makes you buy this book save your money as there are much better books out there for learning VB.



2. I sued this book with "Visual Basic 2005 How to Program (3rd Edition)", so it was complementing.
   This book (as other "Simply" books) is more oriented on GUI. It has tutorials one follows step-by-step. When used in conjunction with VBHtP (mentioned above), it is mote fun than using boring black and white MS-DOS window. So this is positive side of this book.
   The negative side, is (1) if you use it with VBHtP, information in two books (obviously) overlaps, and you find yourself reading same thing twice. But if you use it by itself, there is a prospect that you will need to consult some other source on VB to help you with some exercises. (2) There are typos, and if it is yur first ever programming class, you could get mad over little thing, thinking you doing everything right and it still won't work. I went through about 2/3 of the book and I remember about 3 typos/errors in the code. Now, those are resolvable if you compare code provided in the middle of the tutorial with the entire code given at the end. So, if you stuck, check both places where code found: particular section of the tutorial and the final code at the end of the tutorial. One of them is correct.
   
   As far as the quantity of data is concerned I think VBHtP has more information, but Simply VB presents it more interesting with more GIU components, and tutorial driven approach.



3. The bottom line: This book is poorly, very poorly organized.
   
   There are instructive exercises, but often one idea is not followed through on. The book is very much a disjointed series of design exercises. The topics do not seem to build sequentially.
   
   And then there are the instructions to type some certain code, and the only place to see what code to type is in an accompanying illustration, where the code is set in a tiny font. Very poorly thought out!
   
   Considering the price, you would think that this was a worthwhile book. NOT!
   
   Don't waste your money, because it is a wasteful expenditure. Not worth it!!

5 comments about Python For Dummies (For Dummies (Computer/Tech)).

1. If you have programmed at the level of Visual Basic, or perhaps Excel macros, then this book is perfect for you. It's a pleasure to read -- with its variety of visual aids. In many books, the graphics just clutter the page. Not here. The concepts pop out at you and burn themselves into your memory.
   
   I doubt you can become productive in Python any faster than with this book.



2. From the Dummies title I expected that this was for beginners. The book itself claims that it is suitable for someone who wrote a few Basic programs at one time. I wrote a few Basic programs and it is not. An example: On page 20 it starts a discussion that turns on objects. This is a somewhat advanced topic by most accounts, but the chapter that deals with objects is hundreds of pages later.
   This book that claims that it is suitable for beginners, claims a few pages later that it is more of a reference, really. But it is very poorly organized, as the previous discussion illustrates. Strange stuff like the explaination of Scheme as a functional programming language: In Python for Dummies this is explained as using functions to write programs. Really! It;s that bad.
   The only audience I can imagine for this book is people who know something about Python, but prefer reading about it to programming. Reading it, they could pick up a fe pieces of information they hadn't seen before.



3. This is a pretty decent book for those with some previous programming experience, but is definitely not for beginners (or Dummies) to programming. The first 2 chapters contain terms and concepts that assume an existing knowledge base.



4. I agree with some of the reviewers here, it is definitely disappointing to see a bad seed among the good "... for dummies" series. I have previous experience with programming languages, although this is not my everyday task. I got interested in Python and wanted the book to guide me through the basics. After reading the first 7-8 chapters I started asking myself whether I missed something in the previous ones, as I lost track (and interest) in the book.
   I found the examples parsed in the chapters rather useless, and not practical. Since, I have found several useful on-line tutorials on www.python.org, where the user is taken through the chapters in a gradual, progressive way. The examples and exercises in a beginner's book should be based on what is learned in the previous chapters, giving the reader the idea that what is learned is put in practice, thus easily assimilated.
   
   I don't recommend this book for a complete novice, as she/he will lose interest in Python programming very easily! This book has the advantage of presenting the main and most important features of the Python programming language, but it sues a more advanced audience.
   
   The low rating is indeed due to the non adequacy of the book for beginners and for not following the good standards of the "...for dummies" successful series.
   
   Sacha



5. I have read a couple dummies books and usually they are more of an introductory baby steps type of book. This was not the case. It feels they tried to offer more and it ended up coming across as babble.
   
   I found myself getting bored at times. I can program in Perl and I started this book knowing I might be above the topics at times. I was looking to this book as an introduction to Python. The examples given were not as good as I would have liked. Overall, I don't think the presentation of topics were not good. For example, I thought two chapters on OOP was overkill for this type of book and probably should have been reduced to a chapter on the bigger things you may do.
   
   I mention the examples again as I usually like to enter them for the fun of it. However, they really don't give a good feeling for the power of python.
   
   I did like the spider example but it was lightly discussed.
   
   The last two chapters I think were most useful for the links and other modules that were mentioned.
   
   I should say glob was mentioned and I think the book should have talked about it more then just a passing mention.
   
   So will I suggest this book? Probably not. It really depends on the person. I think it has to be a person that is between beginner and somebody who knows how to program.

5 comments about Web Services Essentials (O'Reilly XML).

1. This book is really lacking on much useful information. It's mostly a high-level overview. For anyone seriously interested in web services I'd recommend getting a different book!



2. This book is really an excellent one for programmers who want to start with web services. It gives a compact overview of XML-RPC, SOAP, UDDI and WSDL. Especially Java programmers will find some good code listings. But don't expect more than an introduction to web services.



3. This book is based on obsolete specifications and older SOAP implementation which is not even available for download. The Apache SOAP is already a piece of junk and Apache recommends to use Apache Axis (which is not in the scope of this book). All other implementation examples such as XMethods and UDDI4J are also obsolete as well. The APIs are already deprecated and the code discussed does'nt make any sense.



4. First of all, to clear up someone else's comment:
   while the API samples, URLs, etc. in the book are all outdated but even beginners should be able to figure out the updates.
   
   The only word of caution: it does NOT cover REST.
   
   This book provides a wonderful set of core topics and values that are essential to understanding what is currently out there (at the time I'm writing this in close-to-mid 2007, anyway). Providing samples, history and general information on each topic covers allows this book to be a wonderful, thorough introduction to the world of WS.
   
   Samples focused in Java and Perl help keep things simple, while there is more of a focus on the Java world. The APIs changed, but since the author references primarily open-source, it is easy to figure everything out.
   
   I recommend this book at this time, but can definitely see it being completely out-dated by the same time next year.
   
   As with many emerging technologies, however, I think this is a must have in order to better understand and follow the evolution of its realm. Since it provides pointers/references to pieces of the puzzle(s) even before its publishing, you can gain even more insight and possibly make some educated decisions as to where the future will take it.
   
   Recommended for all, if for nothing else, as a general reference and "emerging history" lesson.



5. This is a well written overview for those that may have missed how Web Services rushed onto the scene earlier in the decade. Being 5 years old now, it is definitely out of date. I consider about 120 of 300 pages useful as an introduction to the subject to a developer who has been working in other technologies. It provides a good overview. The examples provided work well to illustrate the point presented. Keep in mind that the examples are outdated so skip liberally.
   After reading/skimming this as an introduction, find a more current book for more hands on examples to work through in the technology you intend to use.

5 comments about Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level.

1. Back in "the day", you really couldn't write high-level code without at least some exposure at some point to lower-level code, like Assembler. Now, you can pretty much be completely ignorant of what happens in your Java or VB code "under the covers". But that doesn't mean you can't benefit from understanding how your compiler turns your readable code into machine-readable operations. Randall Hyde does an excellent job in explaining all this in his book Write Great Code Volume 2: Thinking Low-Level, Writing High-Level.
   
   Contents: Thinking Low-Level, Writing High-Level; Shouldn't You Learn Assembly Language?; 80x86 Assembly for the HLL Programmer; PowerPC Assembly for the HLL Programmer; Compiler Operations and Code Generation; Tools for Analyzing Compiler Output; Constants and High-Level Languages; Variables in a High-Level Language; Array Data Types; String Data Types; Pointer Data Types; Record, Union, and Class Data Types; Arithmetic and Logical Expressions; Control Structures and Programmatic Decisions; Iterative Control Structures; Functions and Procedures; Engineering Software; A Brief Comparison of the 80x86 and PowerPC CPU Families; Online Appendices; Index
   
   This is the type of book that will really excite you if you're wondering why a nested if statement performs differently than a case statement. Hyde explains basic compiler theory, and applies that to how your compiler of choice decides on optimization strategies. It's impractical to get a program optimized for all factors, like code size and speed, but there are reasonable trade-offs as well as compiler options you can use to prioritize one factor over another. You also don't have to be completely conversant with Assembler in order to work through this book. He uses a number of high-level coding examples from various languages (like C, C++, and Pascal) that should be understandable to most any IT developer. He then shows the translated code at the assembler level and explains why a particular compilation might be good or bad (depending on your requirements). Once you start to understand how (and why) your compiler "optimizes" your code, you can make more intelligent choices as far as programming constructs. There is often a dozen ways to do something, but a few of those ways will be far more efficient at the machine level than the others.
   
   If you're writing a program that runs in a second or two, these techniques may not necessarily have an immediate practical application for you. But that hour-long program may have the same underlying problem as your first program, and it could be that a slight change in program structure at your end could dramatically reduce the run time. This is one of those books that most serious software developers should have sitting on their shelves...



2. The first 100 pages of this book were fantastic for concepts. After that, there were numerous code listings of various dialects of assembler that were each several pages in length. The premise is that you should learn to read assembler so that you can write better high level code. However, there is no tutorial on what the various assembler keyword instructions mean. This book feels like it was slapped together because it was the long overdue volume two in the series, and has so many references to the first volume that you practically need to own both. There is not enough on Java (or OO in general) as the reader's high level langauge of choice, and far too much on Pascal.



3. In this RAD time when anybody who knows drag-and-drop can proudly claim himself software developer, this is the unique book for true, serious, and hardcore programmer that writes native codes. I completely agree that, in order to write efficient and optimized code, you not only need to understand what your compiler can do for you,but also you should know, at least for a minimum level, what you can do for you compiler. In this regard, this book does an excellent job explaining the magic your compiler does for you and what you can do to become part of the magic. As such, I highly recommend this book to any serious programmers.
   
   The only thing I don't like about this book is that it appears to be giving too much space to HLA, which I suspect is a widely accepted assembly dialect that was actually used in any real-life project. And I just feel it is a waste of my time trying to understand and catch up with this HLA language. This results in my taking one star off with the final rate of 4 stars.
   
   Other than that, this is indeed a very good book.
   
   In a previous reivew, it is complained that Java is not touched. This is understandable while it really doesn't seem to be a problem to me. Java after compiling is translated into bytecode that has to be executed on the virtual machine. I guess that is really beyond the intended scope of this book, which is related to the world of native codes that after compiling can be directly executed by the machine.



4. How Software Works would also be a great title for this volume. Any high level construct you can think of is analyzed in-depth at a low level. This is great for those interested in reverse engineering or writing cleaner code.
   
   This book is language and hardware neutral. Languages from Pascal to C++ to Visual Basic are covered on hardware from x86 to RISC to embedded systems. No matter what language you code in the innards are laid out for you. The author does a masterful job of the idiosyncrasies of different languages seamlessly without dwelling on the trivial. This book is heavy on assembled code, compilers, and interpreters. It's an absolutely great collection of everything you wanted to know about how software works that you really can't find elsewhere in a single volume.
   
   Although the subject matter is probably dry for some, I found this book surprisingly easy to read due to the clarity of the writing. This is at least as good, or better than volume one. With that said, there are a number of references to volume one, and I do recommend reading volume one first unless you have a solid background in computer architecture.



5. I read the first volume of this book, and it was a great, informative read. After volume 2, I have this to say:
   
   This book is not a cookbook for writing better code. Hyde explains why certain programming constructs are better than others (and in what cases), and backs it up with evidence from the assembly code (that is the entire premise of the book). Finally, solid proof of (and against) what I've been hearing all along from instructors and other programmers on message boards or face-to-face communication. That in mind, it would have been nice to have a summary of the tips at the end of the chapters, or the end of the book, as a quick-reference kind of thing. These concepts are the perfect thing to consider when fine-tuning your code. I take the stance that if you fine-tune as you go, you have less work later, so I took notes as I read and have started implementing changes for the better (with evidence that it is better) in some of my coding.
   
   Does anyone write code in Pascal anymore? Seriously? Hyde discusses examples in C/C++ and Pascal for the most part (favoring Pascal, by my estimation), so it is nice that the book is language-independent for the reader. The assembly examples in the book are in 80x86 and PowerPC...I think it would have been better to release two versions of this book, one where the assembly is 80x86 (because it is so ubiquitous, if for no other reason), and then another where the assembly is in PowerPC assembly. I didn't pick this up to become an assembly language programmer, and quite frankly, the PowerPC examples just confused me. It looks like my cat stepped on my keyboard and it appeared in print.
   
   The tone of the text is sometimes condescending (especially in the first 5-6 chapters), with a not-so-subtle "real men only code in assembly" message. It seriously reminds me of my parents/grandparents whining about how hard they had it growing up...walking barefoot to school in the winter...and only having assembly to work with in writing programs.
   
   So by the end of this book, I think I have met Hyde's goal for the readers. I can't sit down and write an assembly program, but I can read enough assembly to compare different versions of my high-level program to say what is better. As the subtitle suggests, I am "thinking low-level" now as I write my programs (in C...which most programmers would call low-level). I suggest "actively" reading this book and coding up a few examples with your compiler and examining the output, following along in the text. Doing that really made the material click for me.
   
   Overall, it's a good book and definitely worth it. This is a long one though, and takes some time to digest. See you in volume 3!

5 comments about Sams Teach Yourself Visual C# 2005 in 24 Hours, Complete Starter Kit (Sams Teach Yourself).

1. I have started learning programming about 6 months ago, reading several books. All the books have been on different programming languages at a beginners level.
   This book is definitely geared towards someone that wants to learn programming with Visual C#. I think this book is one of the best I have ever read. I am finding myself wanting to pick this book up and continue learning.
   
   I would totally suggest this book to anyone.
   Great Book!!



2. I have been programming for a very long time with a lot of VB6 experience. Before that I came from VB3, Delphi 1 and Clipper. I didn't need the programming aspect, I just needed to get acquainted with the C# syntax and the VS2005 IDE.
   
   This book is well organized and easy to follow. It delves deep enough into each main area far enough to show you what to do and where to look for more information. Being a guitar player myself, I also enjoyed the fact that there were guitars, amps and pedals used as .jpg examples!
   
   No complaints here!



3. This product did not deliver after all the good reviews I read on amazon. The book is clearly translated from the visual basic equivalent, as a result certain exercises have hints that are putting you on the wrong foot and dont make any sense at all. The book left me with alot of questions especially on the syntax of the language, and frustrated me with its lack of providing insight on what I was doing.



4. Very good book to get started with VC#
   The book was a little to slow in the first 2 parts



5. This book available in Online Reader form. I don't reccomend it. The viewer gets stuck, skips pages (requires restaring the browser) and even submitting a bug report generates a response from Amazon that "There is an error...".
   
   Biggest problem with this book is the online reader lets you zoom in only 1 time which makes reading the example code impossible.

5 comments about Effective awk Programming (3rd Edition).

1. This book is being picked up by the O'Reilly people. I have many of the O'Reilly books on my book shelf. There will be a third edition due out in July with Robbins as the author. I read though this book and thought it as good or better than the "Sed & awk" book that O'Reilly presently has out. Robbins is also an author on this book. I thought the book to be better than the "AWK programming language" by Aho, Kerninghan and Weinberger, the original authors of the AWK language. I recommend the book to beginers as I am.



2. Awk is one of those handy Unix tools with which you can easily impress people. Using a simple

   /pattern/ { action }

   syntax, you can construct powerful one-liners. Do you want to how much time in total you spent surfing the Internet? Here it is:

   awk '/Connect time/ { s += $8 } END { print s }' /var/log/messages

   It doesn't get much shorter in any other programming language, does it? Need to strip text of HTML tags? Need a frequency count of words in a text? Awk is the perfect tool for tasks like this. With its pattern-action structure, powerful regular expression mechanism, associative arrays and basic program flow control, it provides a powerful tool for manipulating flat text files. Even though other scripting languages may be richer in features, there exists a niche where Awk is just the right tool to do the job.

   Arnold Robbins, the author of this book as well as of several other books on Awk, serves also as the maintainer of GNU Awk (gawk for short), the most influential version of Awk available today. With the version 3.10, released in 2001, GNU Awk became richer for a handful of new extensions over traditional Awk, most important among them are the TCP/IP networking and the support for internationalization. All new extensions are described in the book. How successful these new extensions will be is doubtful, however. Networking scripting niche is already well covered with Perl and Python, and internationalization doesn't really matter much in short throw-away scripts Awk is usually used for.

   With all due respect to the creators of Awk and their book (Alfred V. Aho, Peter J. Weinberger, Brian W. Kernighan, The Awk Programming Language, Addison-Wesley, 1988), I have to say that "Effective Awk Programming" is probably the best Awk tutorial on the market today. If you are serious about learning Awk, you shouldn't be without it. If you are still hesitating whether it wouldn't be wiser investing those 28 USD elsewhere, here is chance to read it before you buy it: install GNU Awk 3.10, and the Texinfo source of the book comes with it. But sooner or later you will find O'Reilly RepKover binding too tempting...




3. Awk is a powerful tool to perform search, and pattern matching on the strings/files.
   
   This book is an essential for people writing unix scripts and doing system administration.
   
   It gives you insight on how things work, and has very nice examples and tricks to perform the tasks.
   
   Mostly the majority of the tasks are covered in the beginning, and the deep rooted tasks, are covered in the later chapters.



4. This book explains both the awk language and how to run the awk utility. You should already be familiar with basic system commands, such as cat and ls, as well as basic shell facilities, such as input/output redirection and pipes. This book describes the awk language in general and also the particular implementation of awk called gawk. gawk runs on a broad range of Unix systems and has also been ported to Mac OS X, MS-DOS, Microsoft Windows, and VMS.
   
   Many people are familiar with O'Reilly's book on sed and awk, but not this book. If you want to zero in on awk and its capabilities, this is really the better of the two books. It makes an excellent tutorial and reference for system administrators and anyone else that wants to use awk to extract and format text. The following is a description of the book from the context of the table of contents:
   
   Chapter 1. The awk language and gawk - talks about the basics including how to run awk, when you should use awk, and starts you off with a few simple examples.
   
   Chapter 2. Regular expressions - introduces regular expressions in general, and in particular the flavors supported by POSIX awk and gawk.
   
   Chapter 3 Reading Input Files - describes how awk reads your data. It introduces the concepts of records and fields, as well as the getline command. I/O redirection is first described here.
   
   Chapter 4. Printing Output - Besides basic and formatted printing, this chapter also covers I/O redirections to files and pipes, introduces the special filenames that gawk processes internally, and discusses the close built-in function.
   
   Chapter 5. Expressions - describes expressions, which are the basic building blocks of awk patterns and actions.
   
   Chapter 6. Patterns, Actions, and Variables - Each awk statement consists of a pattern with an associated action. This chapter describes how you build patterns and actions, what kinds of things you can do within actions, and awk's built-in variables.
   
   Chapter 7. Arrays in awk - describes how arrays work in awk, how to use array elements, how to scan through every element in an array, and how to remove array elements. It also describes how awk simulates multidimensional arrays, as well as some of the less obvious points about array usage. The chapter finishes with a discussion of gawk's facility for sorting an array based on its indices.
   
   Chapter 8. Functions - describes awk's built-in functions, which fall into three categories: numeric, string, and I/O. gawk provides additional groups of functions to work with values that represent time, do bit manipulation, and internationalize and localize programs.
   
   Chapter 9. Internationalization with gawk - describes the underlying library gawk uses for internationalization, as well as how gawk makes internationalization features available at the awk program level. Having internationalization available at the awk level gives software developers additional flexibility - they are no longer required to write in C when internationalization is a requirement.
   
   Chapter 10. Advanced Features of gawk - a "grab bag" of items that are otherwise unrelated to each other. First, a command-line option allows gawk to recognize nondecimal numbers in input data, not just in awk programs. Next, two-way I/O, discussed briefly in earlier parts of this book, is described in full detail, along with the basics of TCP/IP networking and BSD portal files. Finally, gawk can profile an awk program, making it possible to tune it for performance.
   
   Chapter 11. Running awk and gawk - covers how to run awk, both POSIX-standard and gawk-specific command-line options, and what awk and gawk do with non-option arguments. It then proceeds to cover how gawk searches for source files, obsolete options and/or features, and known bugs in gawk. This chapter rounds out the discussion of awk as a program and as a language. While a number of the options and features described here were discussed in passing earlier in the book, this chapter provides the full details.
   
   Chapter 12. A Library of awk Functions - One valuable way to learn a new programming language is to read programs in that language. To that end, this chapter and Chapter 13 provide a good-sized body of code for you to read, and hopefully, to learn from.
   
   Chapter 13. Practical awk Programs - presents a potpourri of awk programs for your reading enjoyment. The first part describes how to run the programs presented in this chapter. The second presents awk versions of several common POSIX utilities. These are programs that you are hopefully already familiar with, and therefore, whose problems are understood. By reimplementing these programs in awk, you can focus on the awk-related aspects of solving the programming problem.
   
   Chapter 14. Internetworking with gawk - describes gawk's networking features in depth, including a number of interesting examples and the reusable core of a gawk-based web server. The chapter is adapted from "TCP/IP Internetworking with gawk", by Jürgen Kahrs and Arnold Robbins, which is a separate document distributed with gawk.
   
   Thus chapters 1-11 form a tutorial and reference on awk itself, and the last three chapters are additional material for reference or your own personal toolchest of programs. The last chapter is more of a curiosity than anything, since I don't know anyone who does internetworking with gawk, but it is still interesting material. I highly recommend this book if you plan to use awk extensively.



5. Every once in a while I am told to panic and get something done in an unreasonable amount of time. When the "something" involves text processing I sometimes return to AWK, and last night it saved my bacon once again. This book has never quite given me the sort of reader experience I'd hoped for, but it does get the job done and can help you do the same.

5 comments about Expert C# 2005 Business Objects, Second Edition (Expert).

1. This is an exceptional book. It provides both the examples of how-to use the framework and how it is built. This internal view of the framework provides invaluable insight into the internal workings of reflection and gives real world perspectives to using objects consistently in a distributed architechture. I like the book!



2. This book has a very good discussion of frameworks and includes the details of the CSLA (Component Scalable Logical Architecture) framework. However, I don't believe the book is worthwhile for the discussion of frameworks alone. If you're required to use CSLA, then this is the book for you.
   
   I give the book three stars because its contents can't be separated from the design of CSLA. The problem with CSLA is the layers. The use of "fat", fully encapsulated business objects has fallen out of favor recently and is not the best architecture for enterprise applications. Despite what the author says, I don't believe CSLA is truly a layered architecture, either.
   
   The book lacks a discussion of when CSLA is a good choice and when another architecture is better. Choosing to use CSLA pre-determines your architecture (the "A" stands for "Architecture", after all). You should always choose your architecture based on your requirements and never select an architecture in advance.
   
   That said, CSLA can be a good architecture for smaller projects. New developers often have issues understanding true multi-tiered architectures. Because CSLA uses an encapsulated architecture that's similar to the OOP training they had in school, those developers may find CSLA a good choice because it's easier for them to understand.



3. Author spends too much time in theory and less time showing real examples. Author wants you to down load code and spends time discussing bits and pieces of each section. Very, very, very steep learning curve. Not a good investment - wish I could find a CSLA book that teaches you step by step....



4. The book itself is somehow disappointing. Sounds like the old vb6 bo book, rather outdated.
   The main concept involved as a guideline on design is the fat table module object arbitrarily called business objects by the author, when the market is more oriented to model domains. Why should we choose fat objects instead of other solutions? It is not discussed on the book.
   A big issue is the way the book is written. He assumes you are a vb6 person. The author is not fully aware of the asp.net architecture. Look at this paragraph about keeping state on the page:
   "There's no automatic
   mechanism that puts all state data into each page; you must do that by hand. Often this means creating
   hidden fields on each page in which you can store state data that's required, but which the user
   shouldn't see. The pages can quickly become very complex as you add these extra fields.
   This can also be a security problem. When state data is sent to the client, that data becomes
   potentially available to the end user."
   
   So he's completely unaware of viewstate object which address all these issues. I think asp.net has gone a long way now and this guy don't even know one of the basic revolutionary concepts brought up by as.net.
   I have constantly the sensation that he is addressing a vb6 developer, but vb6 is long gone.



5. A good written book, it's a step by step trip in the author's mind: from idea through design to coding of his framework. You may not agree with all choices (such as heavy reflection use) but you always know why he did. A good start point to build your own businnes objects and a rich bag for your developer's toolbox.

5 comments about Microsoft Office FrontPage 2003 Inside Out.

1. I learned FrontPage 2003 using 'How to Do Everything with Microsoft Office FrontPage 2003', which is a very good book to start with, but as I developed some skills, I started asking myself questions about how I might go a little further or why some things were the way they were with the program. I found 'Inside Out' gave me a lot of answers to big and little questions that I never saw explained in any other published text (I have five FrontPage 2003 books). Each chapter stands alone, so that you don't have to build up your knowledge to understand any particular chapter by having only read from the beginning. I am using the book right now and improving my website every day. A very good resource. Much better than the FrontPage 2003 Bible, which I checked out from the library. If you are familiar with FrontPage 2003 and want to make FrontPage 2003 your best friend, this is the book to do it! ;-)



2. I actually bought 3 books: Microsoft FrontPage 2003 Step-by-Step, Microsoft FrontPage 2003 Inside-Out, and Que Special Edition Using FrontPage 2003.
   
   Step-by-step is a very useful starting point, but you'll soon run out of this book. By far, the best of the 3 is Que's Using FrontPage 2003 - it is excellent! FrontPage 2003 Inside-Out is good IF you're interested in Active Server Pages.
   
   But all in all - if you want to buy just one I recommend Que Special Edition Using FrontPage 2003. The format lets you learn by solving problems that you run into. For example, you want find out about Banners, the book not only answers your questions but gives you the background and advise on using the feature. And the author is very candid about suggesting when to use and NOT use a particular feature. The authors obviously have used the product for real-world web sites and really wanted to share their experiences and knowledge.



3. A lot of text that's spread out and difficult to follow. Would have been nice to see more examples. eg, constructing drop down menus section provides a lot of text but few examples to carry you through to actually creating drop down menus. More how to and less theory would be helpful.



4. This book was a total failure and utterly devoid of structural instructions which would take an intermediate person from frontpage 2000 to 2003! It seem to be predicated with giving information in a BACKWARD fashion interwoven in such a way that left me more confused and dissatified! If I were to grade this book, I would give it a double triple FFF of the lowest order. How serious am I, well I intend to buy another frontpage book, and I am a senior citizen on SS and money is very scarce!
   I bet the author Mr. Buyen is a self-service pompus conservative nitwit who is 400 pounds overweight!!



5. The definitive resource for FrontPage. This book is huge and covers both simple and technically involved tasks. Good organization and indexes helps you find the subject quickly. Better than other books I found at my library. Note: FrontPage is no longer being developed. The 2003 version was the last. If you want to learn web software and you do not own FrontPage, I suggest you invest in Dreamweaver instead.

3 comments about Sams Teach Yourself Programming with Java in 24 Hours (4th Edition) (Sams Teach Yourself).

1. This book is designed to learn basic programming with Java and it's been working excellent for me. However, in the "HOUR 2" section where you exposed to the first very basic programming, you'd get very confused if you are newbies who are totally rely on Windows XP. I assume that the most newbies have never had to deal with the XP's hidden feature - DOS, these days.
   
   If that's the case, the "HOUR 2" section won't be one-hour session but a couple or more hours right there. If you are somewhat familiar with DOS, then I'd recommend this book. The author explains how to do things in DOS commnad window but I don't think it's enough. Let's say, if you don't know such as CD , MD and all kinds of DOS commands and how to navigate through all kinds of folders and/or directories in DOS window....you won't like this book.
   
   BUUUUT, that's the nature of programming at the first place.
   No visible graphics but just lots of text, text, text and text.:)
   
   Thus, if you expect some kinds of XP's feature such as "Drag & Drop" this book is totally wrong for you. My advise is that please be familiar with some DOS functions, then look for programming books suitable for you:)
   
   The other thins is the book includes a CD-rom, which includes lots of software but by the time you buy it, they'll be somewhat out of the date. If you are using dial-up connections, it'll be a major headache to updated your software for sure.



2. I am just finishing this book, and it is one of the best programming books I have ever worked with. The author has a sense of humor that completely complements the work. I usually find humor in a programming book cheesy and distracting, but Cadenhead's humor is informative and fun at heart, and makes the work go more quickly and make more sense.
   
   The DOS issues mentioned in another review are not a problem with this book. Learning any powerful programming language these days does involve understanding a little bit of what's going on under the hood in your computer. That learning curve exists in almost any language, and each book needs to include it. There is extensive coverage in this book for the difficulties that may arise in this stage, and help for getting around those issues. Once you get your particular system set up properly, you will enjoy playing with the language. There is also extensive online support for these issues.
   
   I am also sticking with the Sams 24 Hour series for other languages, because they are very well done for a wide range of readers.



3. It's great! I was able to (in everyone else's opinion) master Java within 2 days!

5 comments about The Art of Project Management (Theory in Practice (O'Reilly)).

1. The subject of my review pretty much sums up how I feel about this book. After the first 100 pages, I thought to myself "I've gotten a handful of gems and a few good visuals, but did I need 100 pages to accomplish that?"
   
   Seriously, that sums up my impression of the entire book. There is a LOT to be desired in terms of organization and it really feels like there's a lot of good information, but so poorly organized that it's hard to connect ideas. Several times per chapter, I find myself seeing references to how something will be better dealt with in further chapters. I have to ask myself why that happens constantly, and whether or not it says something about the organization of the book.
   
   There also seems to be a tendency to wander away from central topics into tangents or only loosely related ideas. Very rarely does the author tie his thoughts back to what each particular chapter is about, or to a central idea. I have a hard time learning from books that are written this way. I have constantly found myself reading a paragraph in this book and thinking "Okay, but what does this have to do with the aspect of project management that this chapter is supposed to be about?" I tried very hard not to fall into that trap, but it kept happening.
   
   I am an avid reading and an academic, so I know dry reading and I'm not saying that this is dry or anything like that. Quite the opposite, it's witty and fun to read in places. The thing that gets me so much is that it's poorly organized and poorly optimized. I find the author spends way too much time trying to say things and not nearly enough time relating them back to his main ideas.
   
   I have read the authors second book, on Myths of Innovation, and I have to say that I was disappointed by going back to his first book (this one) on project management. I think his second book is excellent and vastly improved upon. It is much shorter than this project management book and MUCH better written, largely in part because of the organization but also because of how concise it is. In retrospect, perhaps he has since improved his craft, but his first outing (this project management book) is definitely tricky.
   
   I see all the positive comments and I believe those people are being genuine about the content of the book. On the other hand, I do believe they have neglected to mention the issues I'm pointing out here. Don't get me wrong, there is useful information here, and lots of it. I have really enjoyed the nuggets that I've found in several chapters, but I lament the page count I had to forge through to get to them.
   
   Again, the content is good here, but the presentation leaves a LOT to be desired. If you have issues with reading books where the author wanders away from central ideas and loses himself in tangents, and where you can easily forget what you're reading about in a particular chapter, you may have difficulties here. If you're just after the book for some good ideas about project management and plan to skim it, you should be okay. Anyone planning to read this from cover to cover is in for some real disappointment.



2. If you're looking to figure out why you're having problems getting your ideas heard or your projects wrapped up on time, ESPECIALLY IF YOU ARE NOT THE PM, this is a great book! Almost any software or system project with companies of any size require "project management" skills from anyone interested in getting things done.
   
   Scott will show you how to better estimate time, see the phases a project goes through, and give you some new perspectives and ways you can improve your product. Easy to read and enough ideas to get you thinking. Right now I'm thinking how much better my professional career would have been if I understood this a decade ago.
   
   Good book, read it!



3. I'm a rookie, so a playbook that organizes my thinking and allows me to execute the plays each day is perfect for what I need. I was surprised at how much of the role of project manager I do right now, and how much of the work is accessible if not desirable to me. The general feeling upon conclusion of the book is that I was just short of an epiphany in thinking, but it helped solidify my suspicions about project management:
   -it is about getting things done through others;
   -it requires a disciplined mind and organizational ability;
   -it can be learned;
   -it can be more rewarding than being an individual contributor.
   
   Mr. Berkun has a lot of commercial software development background, so you'll need to map his model onto yours, but this isn't difficult. The processes for new projects are identical to maintenance work, only you have a smaller timeline and a more focused objective. Really, the ideas and practices scale very well.
   
   Where I was put off, somewhat was in how the footnotes were organized, and how his anecdotes tended to end. Footnotes go at the bottom of the page or, much less ideally, at the end of the chapter. Putting them at the back of the book is the least helpful of the options. I'd have rather seen long parenthetical ramblings than a collection of now-contextless footnotes to read.
   
   The anecdotes were illustrative, but lacked some kind of conclusion or resolution almost every time. "We had a problem, I discovered 'x', and we applied it." So how did it turn out? There's no reflection upon the efficacy of his examples in many cases, and it's an annoying method of storytelling.
   
   Overall, I'm pleased that I found the book, and plan to use it in my expanded role at work. Once I develop some mastery of daily/ weekly/ monthly planning and execution, I'm sure I'll be able to move onto more advanced study, but I'm not ready, and this book is clearly for rookies with some self-awareness.
   
   -C



4. I'm the author and wanted to make sure you were informed there is a new, updated edition of this book, and its now called Making Things Happen: Mastering Project Management. It has been revised, polished, and enhanced, with 120+ new exercises, a discussion guide, improved footnotes, and much more.
   
   Since the old edition listed on this page is out of print and hard to find, it's selling for twice the list price of the new edition, and, if you care, I get no royalties from used book purchases. If you really really want it for some reason, go for it, but I wanted to make sure you knew there's a better, and likely cheaper edition available.
   
   Cheers and happy reading.



5. This is based on Scott's experience and it will give you good ideas, techniques and advices for project management. But if you're thinking in PMP book this isn't that kind of book.
   I red it three times and each time I learn something new. I strongly recommend read this other book "Applied Software Project Management" from Theory In Practice O'Reilly series.