5 comments about Beginning Visual Basic 6 Objects.

1. SYNOPSIS: I recommend this book for it's presentation of the OOP architecture and the code samples of ActiveX objects and Business Objects. Explanations are easy to read and grasp. There are plenty of simple diagrams that help visualize many of the abstract concepts of OOP. In the step-by-step instructions, there are actual screen shots of what a programmer will see when they write the sample code. DETAILED EXPLANATION OF RECOMMENDATION: I have several Visual Basic books. However, none of them give a simple, complete example of the code needed to construct an ActiveX control that stores it's state values in a property bag. I spent two days trying to write code that would store the values in a persistent property bag. Examples that I downloaded from the Web were complex, and had little or no explanation as to HOW they worked. And explanations that I found were either terse or did not give enough detail for me to successfully construct a Control with persistent state values that a user could alter during run mode then have them save to the property bag object. At Barnes & Nobles I reviewed 40 or more books on Visual Basic. In this book in Chapter 8 "Object Persistence" the author Peter Wright provides step-by-step instructions with the full code for creating an ActiveX control that maintain state information in a property bag object. There are screen shots of how the control and message boxes will appear. The explanations of what, when, where, why, and how the code executes are to the point, easy to read and understand. I only needed one chapter, 23 pages, from this book. Yet I was glad to spend the money to purchase it. Why? It is well written, easy read, has lots of diagrams and screen shots that makes it easy to visualize concepts and control objects, and gave me EXACTLY what I was looking for. I could have used a book of this quality 3 years ago when I began learning OOP on a Java platform. Bravo!



2. I purchased this book recently and I'm very happy with it. I'm an experienced C/C++ developer and have used Visual Basic for many projects on the PC....but not with the object oriented capabilities of VB. This book provided the necessary backgound on how to create real world applications using VB objects and provided good background on ActiveX Components (COM) as it pertains to VB. Just enough information is provided about the theory without putting you to sleep. I disagree with the other bad comments I read about the book. I feel the author does a great job of stepping you through all the ways of representing objects in VB.



3. This book is a very good resource for developers starting out in OOP with VB. Even if you used VB, but never used objects, this book may just convert you to OOP. It will give you a solid foundation on how to create objects in VB, and also how to develop ActiveX components/controls. It is easy to understand, and it reads quickly. Author uses lots of examples, so if you follow along, you'll gain a better understanding of the subject matter. Because this book is easy to understand and it introduces a complex topic in simple terms, it will make you want to learn more about objects and will increase your confidence in what you know. At the end of the book, there is a case study using all the concepts introduced throughout the book--it's a good idea to do the project, as it will help you develop your own solutions on the job. The book also introduces UML, and how to make your own ActiveX controls with Property Pages.

   This book is just an introduction, so for more complex issues like designing business objects, you will need to get some other resources. This is, however, a solid foundation for OOP. If you will understand and know everything this book contains, then you'll be already successful in your job. You can always hone your skills later on as your experience grows.

   Buy it, if you want to understand objects, and don't want to get confused or discouraged with the subject matter because this book will really get you on a good start. If you're taking the MCP exams in VB, then objects and DLLS and ActiveX subject matter will be very easy for you after reading this one. This book is also used at some colleges in their OOP in VB classes.

   The only negative in this book, and it's a shame because this should be a "professional" book, is that it has many typos and grammar errors. The editors did a very poor job on it. However, if you don't mind the English, and just want the tech info, then it's going to be fine, and you'll find the errors entertaining.




4. The good news is that, with the amount of stuff you learn from this book on proper object-oriented programming, you'll feel that my money was well spent. The bad news is that every application you wrote before reading this - eh, you'll want to tear them apart and start from scratch. This book is a great introduction to object oriented programming. The concepts are sound, the explanations are great. The examples [stink]. In a book where he preaches cohesion, you would think that he'd cohesively stick to developing the same example further and further.



5. This is hands down the best book for learning to program Visual Basic using objects. I know because I bought all the others and they simply left me dazed and confused. Perter Wright's perfect sense of what to introduce and when and how to introduce it was key to my learning this subject. Most importantly, he thoroughly documents the code in his examples so no aspiring programmer is left behind.

   This book is simply the best of the best.

No comments about XLIB Reference Manual R5 (Definitive Guides to the X Window System).

5 comments about Indie Game Development Survival Guide (Game Development Series).

1. I was really surprised at the quality of instruction in this book. It teaches the reader, step-by-step, how to develop an indie game. From concept to design, from team building to implementation, and from publishing & marketing to support, this book covers it all. My only wish is that I had found it a few years ago, before I learned some of the things by trial-and-error! This book has helped me be a better developer, both in games and in general. It truly is that good.
   
   The language used in the book is clear and concise. My favorite thing about this book (something most people may not notice) is that every important paragraph ends with a single sentence of instruction that clearly summarizes all of the points covered within that paragraph. This makes it very easy to understand and very easy to read. I would wager that if someone simply read only the last sentence in every paragraph in this book, they would still learn 80% or more of what this book teaches.
   
   I cannot recommend this book enough.



2. Having worked as a multimedia developer, turning into a game developer (at the demand of my boss) without the benefit of going back to school to study and learn game development has been quite a task. I play games, and I have lots of experience developing projects (esp. animations), but have never put any thought into creating a video game. The Indie Game Development Survival Guide is designed specifically for those who know what they want to do, but need guidance in getting it done correctly. The perfect guide for starting things off right, this book seldom leaves my side at work.
   
   The process of creating a Game Design Document, for instance, is invaluable information and this book gives near step-by-step directions in how to do so; creating this document has laid the foundation for development of my team's first game project.
   
   Highly recommended for those who are truly independent, as well as for teams like mine who have worked in a similiar industry and are branching out into the game genre.



3. I really enjoyed reading this book not because it was so much helpful as it was motivational if that makes any sense :) It was a fun read and I'd highly recommend it to anybody trying to write their own game or application and need to listen to somebody other than all the naysayers that infest the programming forums.



4. I can't thank enough the author of this book!! It was really well wrote and everything you ever wanted or needed to know about how to be an indies and survive, you'll find inside this book.
   I highly recomend this book to anyone in the indie life or even if you just want to manage a project of any kind.



5. anyone doing game development of any kind should read this book to get an idea of what things that all game developers (including large organizations) must tackle in every decision they make.
   
   Legal issues, team building issues, art issues, marketability issues, etc.
   
   I really enjoyed the book and hope to put the knowledge to good use some day.

5 comments about Programming Flash Communication Server.

1. If you're a developer looking into real-time server communication using Adobe Flash, this book is a must-have. It guides you thru various levels of application development in an easy to understand format, and provides well documented pieces of code to assist you in the learning process of putting together your project:
   
   Topics covered include:
   
   - learning about components and how to use them
   - establishing and managing client connections
   - publishing live and recorded streams
   - local communication with clients
   - remote communication with outside applications
   
   The book also shows how to build and integrate your own custom components, and how to scale your application using the components that you've created. Other highlights include information on how to use shared objects and server management API, as well as ways to improve both design and performance.



2. Excellent book, stuffed of examples very well explained, easy to read and to understand, essential for who desires initiate or even though to profound itself studies on FlashCom.
   Obligator reference in projects involving FlashCom, either for fast consultations and advanced tasks.
   Excellent approach of subjects as Design patterns and security, yonder a perfect demonstration about audio, video and much more.



3. This book is all about the design of applications using Macromedia's Flash Communication Server MX. FCS MX enables the building of media-rich web applications by taking care of the basic tasks required in the networking of the applications. Thus, you can focus on the application itself rather than worrying about low-level communication details.
   
   Since this book is concerned with situations where multiple Flash applications will be executing on the same server simultaneously, there is going to be considerable effort involved in coordinating events, which is addressed by this book. You should already have FCS installed and running on your server and you should also have Flash MX available on the client. The following is description of the book by chapter:
   
   Chapter 1, Introducing the Flash Communication Server - Acts as an introduction to FCS and an overview of the whole book.
   
   Chapter 2, Communication Components - How the FlashCom communication components encapsulate commonly needed features such as chat, video recording and playback, bandwidth control,and user configuration. These components implement many basic building blocks for your application.
   
   Chapter 3, Managing Connections - This chapter covers connections in more depth past the SimpleConnect component, including how to write custom code to handle various changes in the connection status as well as different errors.
   
   Chapter 4, Applications, Instances, and Server-Side ActionScript - This chapter describes how to write Server-Side ActionScript and work with the objects that control application instances and the Flash movies that connect to them.
   
   Chapter 5, Managing Streams - Offers a somewhat oversimplified but complete example that shows the basic steps in publishing one live stream and subscribing to a second.
   
   Chapter 6, Camera and Microphone - This chapter explains how to use both the Microphone and Camera classes to record live streams. These classes are at the heart of most communication applications involving multimedia.
   
   Chapter 7, Media Preparation and Delivery - This chapter covers many details for compressing and streaming audio and video.
   
   Chapter 8, Shared Objects - This chapter starts an entirely new subject - shared objects, which provide a mechanism for the transmission of data between client and server.
   
   Chapter 9, Remote Methods - This chapter also shows how to broadcast method calls to every movie and application instance connected to a shared object or stream, or send them to and from individual movies using RMI.
   
   Chapter 10, Server Management API - Discusses the Server Management API and its applications, including monitoring a FlashCom Server, gathering statistics on application instances, and managing the log streams.
   
   Chapter 11, Flash Remoting - Demonstrates how Flash Remoting can be used to add data connectivity to FlashCom applications. Flash Remoting can access web services, server-side scripts, CGI applications, XML files, or the local filesystem with the help of an application server such as ColdFusion.
   
   Chapter 12, ColdFusion MX and FlashCom - Teaches some specifics involved in using Flash Remoting with ColdFusion MX and FlashCom. There are some practical working examples shown that demonstrate how you can leverage the benefits of Flash Remoting in conjunction with FlashCom.
   
   Chapter 13, Building Communication Components - This is the first step in building complete applications, and is demonstrated through an extensive example.
   
   Chapter 14, Understanding the Macromedia Component Framework - How to modify an existing component and how to create a new one. Also discusses server-side framework code and its core features and data structures.
   
   Chapter 15, Application Design Patterns and Best Practices - Describes some of the best practices available to application developers. This chapter provides some useful design options, patterns, and best practices that will help you build better applications.
   
   Chapter 16, Building Scalable Applications - Deals with building multi-instance and multiserver applications that don't bog down as the number of client connections increases.
   
   Chapter 17, Network Performance, Latency, Concurrency - Traditional network design issues affect FCS also.
   
   Chapter 18, Securing Applications - Specifically this chapter examines the three A's of security - Authentication, Authorization, and Accounting.



4. Although I'm using Flash Media Server 2, this book is still highly relevant as not much has changed. The core objects and language is the same so I would not hesitate to recommend it for anyone looking to use FMS.



5. If you want to understand programming the Flash Communication Server and it's capabilities this is a good place to start.

5 comments about Tcl/Tk in A Nutshell.

1. 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.




2. 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.




3. 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.




4. 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.




5. 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.

5 comments about Learning Red Hat Enterprise Linux and Fedora.

1. My recommendation is, this is a good book for a Linux novice or someone starting with Fedora for the first time.
   Those with experience, will probably want to pass on this book. Its not likely you'll pick up anything new
   (I didn't). (For those unfamiliar with what Red Hat has done with the split out of Fedora; think of
   Fedora Core 1 as Red Hat Linux 9.1 or 10; if Red Hat had continued the product line.)

   This book focuses on the "NEW" Red Hat Enterprise Linux and Fedora Core 1 Linux user. The book is a relatively
   easy read. Bill McCarty writes a clear and well organized book. From a novice's perspective, the author gives
   you, what you need to get Fedora installed, running and usable. The author does a good job of pointing
   the reader at additional information sources on each topic. The book is short, less than 300 pages.
   This is nice compared to some of the other 1,000 page plus Linux novice tomes; which try to be a "how to get
   started" book and a "general reference" all at they same time; except they don't do either well. Linux should
   be friendly, not scary. First timers shouldn't have to read a Encyclopedia to get started in Linux. I agree
   with the author's choice of brevity for his book.

   One suggestion to the author, would be to include output examples with the CLI (Command Line Interface) examples.
   He does it with the GUIs, so why not with the CLIs???

   I bought the book because "Red Hat Enterprise" (RHE) was in the title. I was disappointed in the fact there wasn't
   more detail about RHE. In retrospect, anyone doing RHE, is probably an experienced Linux person working for a
   company, where RHE is deployed and may even have had formal training on RHE. So why would they need this book?

   My bona fides; I've been using been using various flavors of Unix for an embarrassing long time, Red Hat Linux
   for 8 yrs (from release RH 3.0.3 to 9) and I have been running Fedora Core for about 5 months now.




2. From the title I would have suspected something about building scalable Linux servers for web applications. Turns out the book is nothing like that. It's a ground up introduction to Linux from the end-user perspective. It starts in Windows with prepping a system for Linux installation, works through the installation (replete with lots of screenshots), then goes into the basics of window managers and Linux Office-style applications. The last few chapters go into some depth on working in the shell and shell scripting, but it's pretty light.
   
   This is a solid introduction to end-user level Linux that should be suitable for anyone who is reasonably technical (no need to be a programmer). The only reason I give it four stars instead of five is because of the reliance on numerous screenshots, which isn't the best way to explain things, and is not the quality that I expect from O'Reilly.



3. I wanted a book that could help me with fedora in TEXT MODE. This book looked great and obviously, books from Oreilly are always good so I bought it.

   This book is absolutely NOT a good book to learn Fedora in TEXT MODE because the book is about graphic mode and it wasn't said somewhere. It's all about GNOME and KDE.

   Be sure you use the graphic mode before buying!




4. In my quest to learn Linux, I've been working through the book Learning Red Hat Enterprise Linux & Fedora by Bill McCarty (O'Reilly). This is exactly what I was looking for in a learning guide.
   
   Chapter list: Why Run Linux?; Preparing to Install Linux; Installing Linux; How Linux Works; Using the GNOME and KDE Desktops; Using Linux Applications; Conquering the bash Shell; Installing Software Using the RPM Package Manager; Configuring and Administering Linux; Connecting to the Internet; Setting Up Network Services; Advanced Shell Usage and Shell Scripts; Linux Directory Tree; Principal Linux Files; Managing the Boot Process; Linux Command Quick Reference; Index
   
   This book concentrates more on the desktop and graphical interface aspect of running Linux, which is exactly what I was looking for. While this book won't tell you everything you need to know about any specific subject (like shell programming or networking), it covers more than enough to get you up and running with a complete Linux setup. Using this volume, I've been able to get a full desktop and server setup going with little effort or trouble. By following the rest of the book, I'll gain a solid base of knowledge of Linux, and then I'll be ready to move on to more detailed learning.
   
   Perfect level of coverage for where I'm at, and enough detail to get me up and running quickly... I like it.



5. I found this book to be very readable and a good way of getting up to speed on Linux. The book: (i) guides you how to load Fedora onto your computer, (ii) describes how Linux works, and (iii) discusses Linux applications, networking and scripts. The author also touches on the Red Hat Enterprise version of Linux throughout the text. The Linux installation section is well written with plenty of screen shots showing the various screens during installation. The other sections are also very readable. The book comes with a couple of CDs containing Fedora Core1. A reader may wish to download a more recent version (Fedora 4 is available at the time this review was written). This book is a good springboard in getting into the Linux world with Fedora; however I think that a person will want to supplement this book with a reference on Linux (such as Linux in a Nutshell) in order to get a more detailed coverage on topics.

4 comments about Transactional Information Systems: Theory, Algorithms, and the Practice of Concurrency Control (The Morgan Kaufmann Series in Data Management Systems).

1. Before this book was published my primary reference and personal favorite TP book was "Transaction Processing: Concepts and Techniques" by Jim Gray and Andreas Reuter. At over 1100 pages that book thoroughly covered the basics and drilled down into the nuances of transaction processing in a way unmatched by other books on the topic since it was first published in 1993.

   This book changes that by going far beyond transaction processing. It starts with the same fundamentals as the older book, and even covers many of the same topics, such as concurrency control, but it addresses each topic from a much wider perspective. For example, the discussion of concurrency goes far beyond the issues of transaction processing as a middleware component. It extends into application, database and search issues. Another indication that this book is more up-to-date is the material on queue managers. While they are at the opposite end of the spectrum from transaction processing monitors, they are integral to any discussion of transactional information systems. More importantly, both transaction processing monitors and queue managers are used in modern enterprise architectures. Having both topics discussed in great detail is a major point in this book's favor.

   Personally I intend to keep my copy of the older "Transaction Processing: Concepts and Techniques" because it does cover some of the subject matter more deeply. However, this book has replaced it as my principal reference and if I had to choose between them this is the one I'd go with.




2. Tradicionally, the 'transaction' concept is always discussed at the RDBMS classes in the University. But this book goes FAR BEYOND this wide known implementation; with a solid math foundation (some math required, specially set theory and algorithms ) it shows you there are a lot of 'real-life' transactions that requiere some formal methods for defining their implementation.

   This book has no discussion or topic regarding any comercial vendor technologies (specially databases), and I think this is very good. The Page and Object models for transaction processing are clearly explained. There's a very nice discussion concerning RAID technologies.

   This is not an 'academic' book in all the sense of the word. It can help IT professionals to make better transactional system desing (databases, workflow,e-business,etc).

   I would like some RDBMS vendors will include this kind of theory in their documentation....




3. Exceptionally clear writing. Encyclopedic in its coverage of transactions. Anyone dealing with transactions (not just DB developers) would find this a very valuable resource. If you need a book on transactions, this should be your first choice.



4. Database concurrency control and recovery is one of pinnacles of computer science. An amazing collection of models, theoretical results, and implementation techniques enable thousands of users to simultaneously pound on a large database implemented on unreliable disks and networks, with full confidence that their data will be correctly stored. This book tells how this miracle is accomplished.
   
   I teach database systems and also do research on databases, including systems-level refinements to concurrency control and recovery algorithms. This book has been invaluable to me in understanding the three major aspects of concurrency control in databases: the beautiful theory, the carefully constructed algorithms, and the specifics of the practice.
   
   When this book first came out two years ago, I read most of it over a period of an intense week. That was such an enjoyable experience, because the book is very well structured and written in a smooth yet careful style. The authors ensured that all required concepts were in place before introducing a new concept. And the prose just flows, rendering difficult concepts understandable through well-chosen examples.
   
   Since then I have referred to this book often with specific questions that arose in my research. Each time, my question has been answered fully in the book.
   
   Each chapter ends with a section entitled "Lessons Learned" which summarizes the key ideas of the chapter and just as importantly, states the practical application of each concept. Some concepts have not yet been realized in practice; the authors are up front about this and explain why.
   
   Mike Tarrani's review does a good job of explaining the similarities and differences between this book and the other seminal book on transaction processing, by Jim Gray and Andreas Reuter. Both books have their place, and both should be on the shelf (and read by!) all those who want to understand transaction processing at a deep level. And I agree with Jim Gray who noted in his foreword to the Weikum/Vossen book that it is likely to become (indeed, has) the standard reference in this field.

5 comments about Foundations of 3D Graphics Programming: Using JOGL and Java3D.

1. I was on the waiting list to buy this book before it was released. I was expecting some good intermediate information on JOGL that was along the lines of implementation and Graphics architecture concepts. Boy was I dissapointed. This is a survey of OPENGL not particularly JOGL. This is the kind of book a professor would assign a freshmen programmer to read. They went to far into the details of the matrix mathematics behind the graphics library instead of practical implementation. Dont get me wrong knowing how things work is a must but dont sell yourself as anything more than a survey of graphics programming.



2. OpenGL is one of the most popular graphics languages around. And Java has some graphics capability, in 2d and 3d. But recently, JOGL has emerged. It is essentially a Java wrapper around the OpenGL routines, which are far richer than what comes with native Java.
   
   The book attempts two things. One is a teaching of 3d graphics. Involving the extensive maths, which is mostly matrix algebra. The other is how to accomplish this in Java, using Java3D and JOGL. The first is done fairly well. A good introduction to the most common graphics ideas, like hidden surface removal and transparency. It is unclear, though, how well the second task is done. Java3D seems simple enough. The coverage of JOGL does at least give you an understanding of common OpenGL routines that you'll probably need.



3. This book was theoretically written to be a introduction to OpenGL using the cross platform JOGL bindings. It fails to accomplish this task by providing incomplete instructions to get JOGL working, and extremely confusing convoluted example code. I am a professional computer programmer, and rarely have I come across such bad code. Furthermore, the algorithms discussed in this book are explained by confusing code rather than in words. To top it off, the author(s) must not be fluent in English. I had to read many sentences over several times in order to understand the poor English.



4. This book is of no avail to a student of computer graphics. Not only are the explanations in this book sorely incomplete, they are so poorly written that they require hours of careful examination to determine that they are incomplete. All throughout the book the author leads you on by making you think that you are about to be told something useful. You never are. Additionally, the code given in the book will often not compile or fail to execute properly. You will be very disappointed if you buy this book.



5. I had expected more focus on the word "Foundations", but the brief introduction to output primitives was sorely lacking. For instance, they cover, in detail, the Bresenham line-drawing algorithm, but they completely ignore the midpoint-circle drawing algorithm; it would have been nice to see a Java implementation of this.
   
   I was also disappointed that all of the code in the book is subclassed off of any previous code. This is OK in the first couple of examples, but, when one goes further through the text, it becomes difficult to determine just what methods they are calling in their code, and where they come from.
   
   So, in short, the book should not be used as one's sole introduction to the fundamentals of graphics programming, but it might serve as a good counterpart to learn some Java-specific implementations.

5 comments about Jakarta Struts Pocket Reference.

1. Review
   I recently worked my way through a Struts tutorial and really liked the approach for building web applications. However, the Struts architecture has a lot of configuration files and standard components that are interrelated when building an application. It's difficult to keep all the pieces in the right place in your mind as you're first coding with Struts. This is where the Jakarta Struts Pocket Guide comes into play.

   The authors use a straightforward, documentation style of writing to give you just the core information on all the pieces that make up the Struts architecture. There's no conversational instruction on how to use or how to learn Struts. It is assumed you have the basic knowledge and need to understand the details of each piece. The format usually shows a piece of Java or XML code, explains what that piece does, and then documents each parameter that comes into play. So instead of wading through 50 pages of a book to figure out the web.xml file, you can find the core information here in six pages. You may need additional resources if you want to learn more about a particular feature, but this book will quickly show you that the feature exists and what it is meant to do.

   If you're looking to learn Struts for the first time, hold off on this book until you've gone through a learning guide of some sort (like Programming Jakarta Struts by Chuck Cavaness). You'll need that level of instruction to get up to speed on the architecture. Once you have that down, you'll be able to use the pocket guide to find answers to your day-to-day questions on how the different parts work.

   Conclusion
   If you have already worked your way through a Struts book or if you use Struts on a daily basis, you'll find this a valuable little guide to give you focused answers on a timely basis.




2. I am new to struts and was very happy with how easy this book is to find information quickly in.



3. I have at least four separate struts books, and this is the one I keep turning to whenever I have a question about syntax or properties. It lists them all, starting each tag libraries section with a description of common attributes. It then goes into the separate tags in each library and their specific attributes, with example usage. The tag references I've seen in other books were no where near as complete as what is inside this one.

   This book also includes notes on the usage of different action types, action forms, etc. All in all, an excellent reference.




4. Covers all of the bare bones and some of the guts of the topic in 125 pages. Not for complete beginners, but if youve read the limited docs on the web then this is the next step. Covers web and config xml in just enough detail, explains, form beans, beans in general, actions validation. The tag reference is 70/125 pages which makes sense as this so important to a struts app. Does justice to the html and logic tags. Great size for the desk or train. More books should be in this cut down format - it stops the authors rambling and gets to the point. for USD-10 you cant go wrong. Well edited - no mistakes. I got this with another (not as good but bigger) struts book and the two complement quite well. Go for it.



5. If the reader is not completely new to Struts, this book with the examples zipped with the Struts framework might be enough to develop a Struts based application.
   
   The book has two main parts:
   
   Intro to the usage of Struts and its most important components. (35 pages)
   This part is quite good in relation to its size. The Validator framework could get more space.
   
   Tag Reference. (85 pages)
   Includes many short examples. Tiles are also included.

No comments about Using MultiSIM: Digital Electronics.