5 comments about Documenting Software Architectures: Views and Beyond (SEI Series in Software Engineering).

1. After reading my colleague's comments I rushed out and purchased this book. I, too, am trained and certified in Information Mapping© and was impressed at how closely the approach in this book is aligned to that method. However, what I like most is the fact that this book can be used as guidance for a wider scope than just documenting software architectures because it shows how to organize your documentation requirements, develop clear documentation and manage the entire process from start to finish.

   I also like the clearly articulated and illustrated advice about how to augment text with graphics, and how to select the views and associated graphics to document requirements, specifications and the finished architecture. An example of how this book goes beyond documenting just architectures is a project in which I was engaged two years ago. One of the major deliverables was a set of operations guides. While this is related to architecture with respect to how its used after it's in production, there were no books that fully described how to go about it in a coherent way. Using the advice and techniques in this book I could have greatly improved upon what I did produce. While I cannot change the past, you can be sure that I'll use this book to its fullest the next time I need to write ops guides, especially when it comes to showing component and connector views, and elements and relations.

   If you do technical writing either professionally or as a part of your job get this book and keep it nearby. If you read and use the material you're ability to communicate will surely improve, and you'll be able to tailor your documentation to each segment of your audience (business and technical), as well as to clearly communicate information. You'll also learn much about managing the documentation process itself.




2. This is not a bad introductory documentation book, but quite skimpy in the amount of information and examples it contains.
   Not sure it is worth buying at that price. I bought it after reading the previous reviews - I think they overrated it!



3. Software architecture really is unlike any other aspect of its design. The architecture has deeper meaning and larger scale than any other aspect, and can't be discussed in the same ways.

   This book opens that discussion. Among the "architecture" books I've read lately, this is the only one to offer concrete advice on describing, presenting, and analyzing archtiectural features of a system. It identifies a number of documentation types and variations. It also identifies a number of different readers - developers, future architects, users, etc. - and addresses their different documentation needs.

   The authors use a little UML, but not a lot. For one thing, standard UML works at too low a level for architectural discussion. Classes, and even hierarchies of class inheritance are such fine-grained entities that architecture gernerally won't address them. Instead, the authors offer a number of diagramming styles of their own. For once, I agree with the need for non-standard notation.

   Even so, I think they under-utilize the existing standards in favor of their own terminology and notation. They could have used a UML profile for lots of the discussion. It would have had to be a new profile, however, not just a force-fit of the real-time profile. They also under-used the existing architecture standards (IEEE/ANSI, DoD, NASA, and more) in favor of their own discussion. Maybe their approach can be used in any of those frameworks, but that should have been more explicit.

   I see only one major flaw in this book, the assumption that a software system's architecture describes the program delivered to a customer. That's way too narrow. A large system includes things like test harnesses, debug instrumentation, application-specific QA tools, and user documentation of many kinds. Those can be major undertakings of their own. They are intimately tied to the delivered software, and may constrain the actual product.

   On the postivie side, this book offer an extensive real-world case study. That probably doubles the book's value, by putting a concrete face on the otherwise abstract discussion.

   There are two ways to use this book: you can agree with it, or think about it and disagree with it. If you really think about it, though, you get it's full value whether you agree or not.

   In other words, you can't lose by reading this book.




4. Clements shows how to use various notations to document your software design. Of these, perhaps UML is now the most common. The advice in the text can be used to first design your code, before programming. Certainly, you should somehow have a design laid out first. You do, don't you?
   
   The book offers structural advice about how to do this. From the low level "mechanical" details of the UML notation, to more general conceptual issues. Various possible architectures are outlined. Client-server, n-tier and peer-to-peer. Enough to get you started in implementing these ideas.



5. Simply put, I think this book represents the best thinking about documenting software architectures. You can find other books that include different aspects covered in this book (documenting views, 4+1, ANSI/IEEE-1471-2000, etc). However, you will have a hard time finding a book that pulls it all together, provides the rationale and includes the "beyond" part which discusses other approaches to documenting software architectures and how they relate to the "Views and Beyond" (V&B) approach. For instance, the book discusses how to use V&B to comply with ANSI/IEEE-1471-2000.

5 comments about Twisted Network Programming Essentials.

1. Abe Fettig's Twisted: Network Programming Essentials provides insights on the open source network application framework written in Python. Twisted offers Python programmers a powerful flexible option, producing programs which won't lock up and which are event driven by network events. Its stability and reliability lends to a program which is versatile, very easy for programmers to manipulate, and which can be used to write a web server, enable applications via email, and more. Review the program's strengths with this bible of advice in hand.



2. Are you a developer who wants to start building applications using twisted? If you are, then this book is for you! Author Abe Fettig, has done an outstanding job of writing a book that contains lots of examples of working code, with thorough notes and explanations of how you can use Twisted to do useful things.
   
   Fettig, begins by covering downloading and installing Twisted, and some additional libraries, on the operating system of your choice. Then, the author shows you how you can use Twisted to make TCP connections to servers, and how to write a server that accepts TCP connections from clients. He continues by showing you how to use Twisted to work with the Web. Next, the author shows you how you can design a Twisted web application for programmatic accessing using the REST architectural style. Then he discusses the Twisted authentication framework, which provides an extremely flexible approach to authenticating users against different backends. He also demonstrates Twisted's powerful support for mail clients and servers. Then, he discusses Usenet clients and servers using the NNTP protocol. The author continues by covering Twisted's support for SSH. Finally, the author shows you how to use the tools Twisted provides for running and managing applications, which give you the ability to run daemon processes, use setuid and chroot to limit permissions, and write log files.
   
   The goal of this most excellent book is to focus on practical examples of how to use Twisted to perform some of the most common tasks that face developers building network applications. More importantly, this book will help you to understand the key concepts and design patterns used in Twisted applications.



3. This book was disappointing to me. It does not cover Twisted fundamentals very well or comprehensively, but is rather a collection of few large code-examples and verbose commentary. For an introductory (or 'essentials' as the title state) material to Twisted, you are better off with the online manuals.
   
   Granted, there are a few "oh - that's clever" moments in the book, but those are buried in the examples and hard to look up for future reference.
   
   The bulk of the book shows examples for web clients and servers (simple stuff, not useful since easier-to-use and more powerful tools/libraries exist) and low-level pop, smtp, imap and nntp servers and clients (probably not very common in today's applications).
   
   I haven't used Twisted extensively in a real project, but I have read the online docs and fiddled with small scripts - and the "new" things beyond them that I discovered reading this book can be counted on the fingers of one hand (namely Perspective Broker, authentication and SSH stuff).
   
   I would have liked this book to be a more comprehensive overview of twisted's fundamentals and the base-protocols it provides - with more examples of custom protocols - since that's probably what most people turn to Twisted for.



4. This book is nothing more than a handful of code examples that you can just as easily get from the web. There's nothing in the way of overall architecture, insightful approaches to using Twisted in an application setting, etc. Save your money and read the web pages. Worst O'Reilly book ever.



5. This book will take you through all the packages that will allow you to master the twisted programming.
   Very clearly explains with examples several different situations in which twisted will help you to have your network programming asynchronous and fast.

1 comments about Practical IDL Programming.

1. If you're like me, you've probably been confused at times by the semantics of IDL. I've been using IDL for several years now and I still run into obstacles every now and then. What I needed was a book that went through the basics first (like a C or Fortran book) and then covered the really practical stuff like plotting, imaging, saving output etc. Liam Gumley has done a great job here in showing the reader how to put IDL to work. I also own Dave Fanning's book, and the two books complement each other nicely. However I'd have to give the edge to Practical IDL Programming for it's clear and straightforward explanation of IDL fundamentals, and for very clear and well explained example programs, many of which I now use every day.

4 comments about Game Writing: Narrative Skills for Videogames (Charles River Media Game Development).

1. The days of the super simple games like Pac-Man are long gone. Today's games must entertain with all the finesse and skill of a Hollywood movie. This is not to say that a game must be all narrative, neither is a movie.
   
   This book is the first complete guide to writing stories for games. They are not stories alone, that would just be a book. But nor are they just action games. They are games with a story.
   
   The book is edited by Chris Bateman, an expert in market oriented game design and narrative. He has gotten an even dozen of game developers to contribute in various aspects. They range from game developers to writers, to educators, to journalists. Each is able to bring his/her own insight to the book and to the writing profession.
   
   As computers, software, game engines (and always more memory) develop, games can grow more powerful, more lifelike, more movie like.



2. Computer games are becoming more like Hollywood productions, requiring good plots and valued story lines which use good narrative styles. In Chris Bateman, Editor's Game Writing: Narrative Skills for Videogames are practical articles on how to do so, written by members of the International Game Developer's Association and covering all kinds of game writing, from comedy to plots. A 'must' for any video or computer game writer.
   
   Diane C. Donovan
   California Bookwatch



3. This is a good book. It suffers from having multiple authors in that it lacks the consistent tone that most writng books have, but all the writng is still good.
   
   It is focused on the interface betwen the writer, the game, and the team, and is long on cautionary points. It will be of value to anyone who is writing, producing, or leading all or part of a game team, particularly if they lack practical experience.
   
   If you are only interested in a book about writing for games, Lee Sheldon's 'Character Development and Storytelling for Games' is probably a better choice, but if you are intending or actually writing game, or working with a game writer, this is a good read and a potentially vital resource.



4. Great book for seeing how video games are made!

5 comments about Beginning JavaScript with DOM Scripting and Ajax: From Novice to Professional (Beginning: from Novice to Professional).

1. Don't let the all-inclusive title of this book fool you - it really doesn't seem to teach that much more than what you could learn by reading DOM Scripting (from Friends of ED). DOM Scripting: Web Design with JavaScript and the Document Object Model
   
   I keep running into a custom object in the code examples of the book called "DOMhelp". While I like the author's ideas about scripting in a more object oriented way, this does not help at all when trying to demonstrate DOM Scripting. For example, instead of using the actual DOM methods to get all the links on the page and loop through them, he shows you a line of code that just says "DOMhelp.getlinks". Yes, that line does the same thing by accessing his object and running the regular DOM functions, but what does it teach me? Nothing. That alone is a big enough annoyance to regret buying this book.
   
   This book also pulls the "we'll explain that part later" trick one too many times. It's not that this book is completely awful, it's really that you can find a much better book to teach you more useful (and universal) things with DOM Scripting.



2. I liked this book - it has many real applications and explanations. I found myself slipping in markers on lots of pages so that I could come back for information that I knew I needed or showed a better way to code something that I had already done.



3. He makes me cringe because he describes a lot of practices that are just really cheesy and annoying. People new to programming who start with this book are not going to advance the state of javascript enabled websites. Also, the examples are overly long. There's a 4 page example for each concept.



4. Just be aware of what you're getting into when you buy this book. It is *for beginners*, not for experienced developers. It spends the first 90 pages covering for- and while-loops, if-tests, and the rest of the machinery that you already know if you're an experienced programmer. It is the fate of most computer books, I'm afraid, that they either address rank beginners or professional software developers, with few addressing those in the middle.
   
   After every chapter, I had to take a second to recapitulate what I had just learned into the terminology that I'm aware of from my experience with other languages. One large section, for instance, is devoted to namespace-collision issues -- but the word "namespare" appears nowhere in the index. If you need a book that will jumpstart to "Here's how you solve the namespace-collision problem in JavaScript," this book is not for you.
   
   I had lots of specific questions, having just come to JavaScript. How do I set up a callback *chain*, for instance, on something like the window.onload event? This book is not at that level. It will be unable to answer that question for you. It spends so much time on beginners that it doesn't have enough time to help with best practices or common, cookbook-type programming problems.
   
   And yet it does seem confused about exactly who its audience is. Right after a chapter on basic flow control, Heilmann tosses off "XSLT" as though he expects his readers to know what that is. I submit that those who needed the first chapter will not need the XSLT bit, and conversely.
   
   So just be aware what you're getting into. I'm actually not blaming Heilmann, though I do blame whoever gave the book its title; it's much more about novices than professionals. If you look on the back of this book, you'll see the flow chart that Apress recommends: start with Heilmann's book, and progress into "Pro JavaScript Techniques" and "Pro CSS Techniques." "Pro Javascript" will be my next step.



5. I have been going through a lot of javascript books to find that all of them want to teach you the trivial things javascript can do. Not only are the examples trivial, they teach the reader horrible habits. This book doesn't have any "Hello World" examples. It gets into what javascript SHOULD be used for, and how to use it correctly. Other reviews have said that the examples do not work. Do not let that throw you off. I went through the ENTIRE book and every single example worked for me. There are a few towards the end that require a server or a local host like xampp, but either way they still worked. Another review also complained about the DOMhelp library that Chris creates. Chris explains EVERY method in that library before you use it. The library does not do trivial things like "getLinks" You learn how to do that the regular way with the DOM. I think that reviewer got that method mixed up with DOMhelp.getTarget which gets the correct target that a user clicked on depending on which browser the user is using. That is mostly what Chris developed the library for, browser cross compatibility so you don't have to write extensive code. Simply put, some of the other reviews were not very well thought out. If you want to learn useful javascript the right way with plenty of examples to help you learn it, then this is the book for you.

5 comments about Macromedia ColdFusion MX 7 Web Application Construction Kit.

1. Learning CF or getting more tips on how to improve a website, this author knows how to explain the process.



2. I am a beginning CS student and even though I don't have too much experience programing this book teaches CF in such a simple and easy way. Don't let the simplicity fool you though, though CF is simple, it's also very powerful.



3. I like this book, but it is way too big and I find myself looking for other things to do. It is just overwhelming, but it has a lot of good information.
   
   I really wish there were Quick Visual Pro Guides for CFMX 7 like in previous versions. It seems that no one wants to write anything for CFMX7.
   
   I would really like to see shorter versions of this book that works like a lesson plan.
   
   In all, I really do like the book and would recommend it (especially since it is the "only" book out there that has about every thing in it).



4. If your a CF developer you need this by your side. Alot of the step by steps are the same for version to version of this book but its got all the tags, and functions and their various attributes which is invaluable to your development.



5. I was an ASP programmer for over 8 years. I did some Cold Fusion programming about 8 years ago but nothing intense or very detailed. I needed to learn Cold Fusion again and I reviewed this book and thought it may help. I followed it step by step and I found it very easy to pick up Cold Fusion Programming. This book also covered many details such as custom tags, Cfdocument and many other programming techniques. I highly recommend this book if you are a Cold Fusion Beginner or if you need to learn some other more advanced techniques.

5 comments about Java Messaging (Programming Series).

1. As we look at how much we use the web, it is sometimes hard to remember just how new this concept of worldwide packet switching really is. Java was started as a new language before a lot of the new concepts like XML and SOAP were conceived. But as a new language it has been able to move into using these new concepts faster than nearly any other language.
   
   What I especially liked about this book was the first chapter. So often computer books start with programming. This one starts with a description of what we're trying to do here. He gives several examples of the types of communications that he is going to cover in the book. I had a particular application in mind when I got the book, but in reading the first chapter I began to see several other ways that messaging would help our system.
   
   After the first chapter, I've go to say that it's a pretty regular computer software book. It tells you how to do the things that you want to do. It is quite clear on all the different software protocols, packages, and philosophies. Basically it is all that a Java programmer needs to implement messaging in Java.
   
   The CD included with the book gives you all the sample code from the book, as well as the complete messaging toolkit and several open source tools.



2. Eric Bruno's JAVA MESSAGING explores different ways of messaging using Java software, from JavaBean events and JMS to SOAP. Web programmers receive all the basics to using these features, tips on how and why to use each feature and when to choose something else, how to combine features, and more. The basics of Java communication processes are revealed in chapters which form 'classes' to link related information in a logical progression. An excellent, basic foundation for Java users.



3. Excellent introduction to messaging, including healthy portions on JMS and web services.
   
   The writing style is clear, consistent, and to the point. Probably what I liked most was this no-nonsense writing style. If it's on a page, it's important to understand. The author doesn't waste your time with irrelevant discussions or out of scope topics.
   
   Editing and code presentation are top notch, making it easy to follow, and build upon from one example to the next. The author also shares some gotchas and considerations that I wouldn't have expected to see in an introductory discussion which were particularly valuable.
   
   Another great feature is one of the drawbacks of the book. The framework presented in the book is elegant, but in many of the examples, there is too much cognitive overhead involved in grokking the level of abstraction in the framework, and this takes away from actually learning the concepts. I would have liked to see more non-framework code for the introduction, which is then tied together with the framework.



4. Although the book uses a specific JMS engine for the examples the details and the concepts were all right on and covered everything I needed for JMS. It literally saved my bacon, especially the peer to peer stuff over topics. Whew!
   
   Super job.
   
   Sam



5. As other reviewers pointed out, this is indeed a nice work on Java Messaging. For the most part, the concepts are presented clearly and I had no trouble following them. What's good about this book is that there are enough examples to play with and most of them indeed work as promised in the book. This book uses ActiveMQ 2.1 for JMS Provider while the current version is 5.x. However, the ActiveMQ 2.1 libraries are included in the CD, so using those you will have no problem in running most of the examples. I could not get the examples that use Java Web Service Developer Pack (JWSDP) to work however (chapters 8 and 9). This book uses JWSDP 1.4 version which I could not find on the web (at the time of this writing only JWSDP 2.0 is available for download on Sun's site). The book says that JWSDP 1.4 is included on the CD but it was not. Except for these minor issues, this book is worth reading and owning. Highly recommended.

5 comments about Joomla! Template Design: Create your own professional-quality templates with this fast, friendly guide.

1. I thought I would learn to make joomla templates. But this is just a makeover of one of the standard themes.
   
   I read the entire book and didn't read anything new.
   
   I could not imagine that the publisher of this book read it too, because he would have thrown it in a bin



2. I bought this book to learn how to create Joomla templates. Look at chapters 1, 2 and 3. NOT A SINGLE WORD HOW YOU DO IT.
   
   In chapter Two 3 screenshots how you can change the Rhuck template without coding. But nothing as how this gets done.
   
   In chapter Three the author has the nerve to start with "We continue with our modified Rhuck template" - the changed template he forgot to describe in chapter Two.
   
   Yes, very useful information about what I don't want to know about. Like which color picker to choose, this is a nice editor, that is a great photo editor, and you set it up like this.
   
   Sorry, but if I want to learn how the NVU editor or Dreamweaver works, I look for different titles. That has nothing to do with coding templates.
   
   I expect some guidance as how to change the template css, the related images and the module positions so a newbie template editor can get acquainted with the beginnings.
   
   In fact, if you try on your own, you will find that the author KNOWS you're going to run into trouble on page 15. He describes the area below the top=newsflash as 'this area's space is hardcoded in the xhtml'. If you try to switch the menu's from left to right that little bit sits nicely in the way. The authors knows it, but doesn't care to mention it.
   
   It's like learning English as a second language, and dumping the sonnets of Shakespeare on your desk with the remark "This is what you can achieve if you master the language."
   
   The examples from the website? I tried to install the supplied templates, but even that doesn't work. A complete waste of money.
   
   The book is very expensive. I'd expect a LOT more for this kind of money. Not the first time I am snookered out of money by Packt, but it is most certainly the last time.
   
   For beginners this is worthless. You don't learn anything that you can't find on the Internet with some searching. Actually, I bought this book because I need to code a 1.0 template - and even there it fails miserably.
   
   Barry North book "Joomla a user's guide" teaches a LOT more in a single chapter about creating templates.



3. This is the best and really the ONLY book out there for Joomla. Now, I have to admit that I don't really like Joomla. However, I'm a web designer and occasionally I have to create or work on sites in Joomla anyway.
   
   At first, I bought another Joomla book but all it did was left me confused. It didn't help me and didn't talk at all about fixing up a template to reflect a client's logo and branding which is what I usually need to know. And forget about online documentation for Joomla; it's just not out there. And the interface is not intuitive at all, so you'd think documentation would be a given.
   
   But THIS book is completely awesome and it does what it says it does. The author showed me clearly how to make a Joomla site look the way I need it to look AND in the process, she explained many things about Joomla to me that made no sense at all to me before (for example, why Joomla does some of the things it does, what parts of it spit out html tables and what parts I can really control with my template CSS, etc). Also, the author explained how to make multi-level unordered menu items work (I had previously torn my hair out over wondering why that didn't work in Joomla) -- turns out you need to install a module.
   
   And even beyond Jooma itself, I also picked up quite a bit on how to properly implement web standards and use CSS, which I'd been needing to brush up on. This book has actually helped me with many aspects of my job in general, not just making a Joomla template!
   
   I still don't completely understand why people choose to use Joomla, as I still find the admin interface to be confusing and badly worded, but as long as people use it, they'll need designs for it This book is the only thing out there that makes this possible. I totally recommend it.



4. I have 3 books on Joomla and this is the only book that truly helped me through getting an original design (from another party) into one of my Joomla sites. I run three sites with Joomla, all for non-profit organizations and therefore have to do my work on night and weekends. I'm a web professional and know the concepts of building sites but I'm a manager and don't build sites everyday for a living. This book got me through the template basics in way that allowed me to implement an original design that had no references to typical Joomla page layout areas, in a couple of days. By taking you through the process of designing a Joomla template from scratch I was finally able to understand how a web page was generated by Joomla and how I could eliminate much of the "noise" in the default setup. It's possible that a web beginner may find some things difficult and perhaps a comprehensive description of the Joomla content engine will not be found but I heartily recommend this book if you need a jump start of creating templates for Joomla.



5. The style of the book worked very well for me. It was a great balance of solid instructions and visual examples that made it very easy to understand and follow. I have other books by this author and highly recommend for the novice to those more advanced who may need a refresher.
   
   Kudos to the author and Amazon for carrying this selection!
   
   R. Pettway

No comments about CRM as a Rapid Development Platform.

2 comments about Pro Java EE 5 Performance Management and Optimization (Pro).

1. This is a one of a kind book. It is the only one that discusses performance maintenance and optimization for all your Java EE applications, from code to servers.
   
   The first section covers processes that you need to have in the full lifecycle of your application. Starting monitoring and performance tuning early on in the process to make it easier to keep your app performing at its best.
   
   The second part covers performance tuning, where to best tune your application for the biggest bang for your buck, from the JVM, first place to tune, to your pooling and other configurations.
   
   The third part covers tuning your production environment, which should be easy, as long as you have statistics already from your development to test server load balancing.
   
   And finally the last part has tips and tricks.
   
   For just the 10 pages on JVM Heap/Garbage Collection and tuning alone is worth the price of the book.
   
   This book should be your single source of performance tuning and monitoring for all Java EE Applications. It is your bible on performance.



2. This book is an invaluable resource for any Java EE architect, or sysadmin working in this environment. It exposes in great detail all aspects of performance tuning and management, providing excellent advice on how to plan, develop and monitor your applications ensuring that they perform as expected.
   My favorite parts are the authors approach to application server configuration and JVM heap tuning. A lot of examples with great expert advice, definitely worth it!