5 comments about XAML in a Nutshell (In a Nutshell (O'Reilly)).

1. The previous post says nothing about the quality of this book and thus should be considered a definition of the XAML technology rather than a review.
   
   In my opinion this book seemed slapped together. It was as if the tech writer of the documentation paraphrased the MS XAML Help. There was very little usage of metaphor or humour to make the topic interesting or easier to understand.
   
   The code examples are extremely simple and unimaginative. In one of the very few lame attempts at humour the author comments about an animated rotating square and states that, "It may not be very useful, but it sure is fun to watch." I found this attempt at humour insulting. Can you imagine having a conversation with someone who talked like this?
   
   If you are like me and you really like to have a paper version of bleeding edge tech stuff, you can be can be forgiven for purchasing this drivel. If you want to save yourself some hard earned cash, just download the MS Expression Interactive Designer CTP and work through the examples. You will learn more doing this in less time. In fact, unless you are stuck on the bus, you are wasting your time with this book.



2. This is one book that could have benefited from a firm critique while still in proposal form by someone cognizant of the concerns of the potential audience.
   
   A book about a technology not ready for prime time cannot focus on code snippets. It must be an advocacy book, a book that speaks directly to us skeptics in the coding trenches. It must motivate the hard work entailed in learning a new tech by giving us a glimpse of a better future if we do. This book fails in that.
   
   The first concrete questions a knowledgeable person will want answered by the book is "How is XAML better than XUL? Can it do more or do it more easily?" The only mention of XUL is on page 4, where we are informed "XAML offers similar benefits to other markup-based application interface mechanisms such as XUL..."
   
   Well yes, "similar," except that XAML, unlike XUL, is not cross-platform, not implemented, and not tested in production applications.
   
   This book found me a skeptic and left me an irritated skeptic.



3. Are you a .NET developer and/or user-interface designer that is familiar with HTML and the basics of XML? If you are, then this book is for you! Author Lori MacVittie, has done an outstanding job of writing a book that gives the reader a broader sense of the XAML market.
   
   MacVittie, begins by providing you with a quick introduction to XAML and includes a list of references to tools available for developing XAML applications. Then, she details the system prerequisites and basics necessary to begin developing and building XAML applications. The author continues by describing the core XAML syntax and delves into the types of elements used to create XAML applications. Next, she details how to position individual elements using a variety of techniques, including panels and absolute positioning. Then, the author provides an overview of resources, focusing on the use of global resources to create a customized look and feel for your interface. She continues by detailing the mechanisms available for animating XAML elements. Next, she details and provides examples for the basic elements used within XAML, including Brush and Pen, ListItem, and elements used for text decoration, such as Inline, Bold, and Italic. The author continues by detailing the control elements available within XAML, such as Button, CheckBox, ImageViewer, and Expander. Then, she explains the differences between shape and geometry classes and details the Shape and Geometry elements available within XAML. Next, she details the XAML elements used to lay out user interfaces such as Grid and Panel, and describes supporting elements such as Trigger, Style, and Border. The author continues by detailing the types of animations and transformations available to XAML elements. Finally, she explains the WPF event system and details the events available to XAML elements.
   
   This most excellent book gives the reader a quick reference to XAML with examples. In other words, this book provides documentation of all core components and presents detailed discussions on features such as animation, resources, and layout that will jump-start you on your way to becoming a XAML developer.



4. Reading over some of the other reviews listed here, I feel that this book is getting some harsh criticism that is simply not justified. This is an OVERVIEW book folks, not a comprehensive resource that will turn you into an uber XAML programmer overnight! This book touches upon topics quickly and swiftly. Usually I appreciate brevity, but in this case being short doesn't necessarily help or hurt this book. If you want a quick read that will teach you some of the ins and outs of XAML, this is a nice book to do just that. If you need a more extensive look at the technology then pick up another guide but don't bash this book for being what it is.
   
   Here's an overview of what to expect:
   
   01. Introducing XAML
   02. Getting Started
   03. XAML Basics
   04. Layout and Positioning
   05. Resources
   06. Storyboards and Animations
   07. Elements
   08. Controls
   09. Shapes and Geometry
   10. Layout
   11. Animations and Transformations
   12. Events
   
   Along with this, you get 8 appendices covering the major parts of the XAML technology.
   
   If you want a quick intro the technology, this is a nice pickup.
   
   **** RECOMMENDED



5. I got this book when it was barely three months on the market.
   Since WPF (aka avalon) is such a new topic, there are barely any books to teach it. This one is relatively clear and consice. The problem is that the WPF version thay are referring to is obsolete. Many concepts and most examples do not work as is. The whole chapter about Storyboards and animations is completely irrelevant.
   I believe that a new version is needed, and I am sorry that I bought a three months old book which is obsolete, but I can not blame the author, she did a good job.
   
   Regards

5 comments about Karel++: A Gentle Introduction to the Art of Object-Oriented Programming.

1. With the use of this book and associated software, one can master the C++ or Java language in no time at all! It uses the analagy of a Robot, and the simple classes that operate it. Due to the fact that it has simple classes, time is not wasted trying to remember the many classes and their functions, and the reader immediatly begins programming the Robot. The Karel++ language has the Syntax of C++, and is Object Oriented (just like Java and C++). This is a must buy for anyone getting into programming, or just learning OOP (Object Oriented Programming)!



2. This book is meant for the earliest of beginning programmers. If you have any programming experience whatsoever, even with macros, the information in this book will seem extrememly remedial. Also, some of the terms used aren't even real C++ code, so you'll have to adjust your thinking just a little when you move on. Finally, the price is pretty steep for the amount of information you get. I would probably only recommend this book for someone needing a very, very, VERY gentle intro to programming.



3. I had to read this book for an introductory programming class and didn't find it at all helpful when going on to Java. It wasn't worth the time I spent working with it. You'd be better off just beginning the object-oriented language you're interested in. If you want my advice, try Beginning Java Objects by Jacquie Barker instead.



4. This book reminds me of the older LOGO programming language. You have a small "robot" that explores his world. You tell him how to move and what to do. The only reason this is good is that it helps you think of object oriented programming. (The robot is considered an object). There are also special editions of the book in case you want to specifically move to C++ or Java later. Basically, the book is a good start. If you have any programming experience - skip it. Otherwise, it will get you in the rate frame of mind to move toward OOP.



5. This book was the text for one of my intro to programming courses. I had no choice. You do. Run while you can.

3 comments about Real Time UML Workshop for Embedded Systems (Embedded Technology).

1. I haven't had this book long, but it seems to provide an overall approach to using UML in several RT systems. Several of the example "systems" are used in the models presented througut the book. It goes through the examples systems for requirements analysis and modeling. It's a problem/answer style "textbook". It provides a brief introduction to UML in the initial chapter, which might not be enough if you are fairly new to modeling or the use of tools such as Rose, RMS, Rhapsody, or EA. The book contains a CD that has a demo version of Rhapsody that says it can generate code for an ARM9 target, for which it includes the Keil toolset and target simulator. It's a fairly readable book, even if you don't do all the examples and just look at the answers.



2. The many examples of UML are perhaps the best feature of the book. They give you practical insight into applying the UML diagrams. And may well be easier to follow than to look at the formal UML specs.
   
   For added motivation, the examples are all drawn from designing embedded systems. When, for example, you might see a state diagram, with all the states laid out. In general, UML is not confined to this field. Any given example could easily be re-imagined, with the UML boxes redone for other fields.
   
   The format of having questions with comprehensive answers will be very helpful to some readers. Most books on UML simply don't bother doing this. Which might be valid for experienced programmers. But for neophytes, this book could be a better read.



3. If you design and develop Real-Time and Embedded Systems, this book is absolutely a must, as well as "Real-Time Design Patterns" by the same author.
   Perhaps the two case studies treated in the book are not the best choice the author could make. Nevertheless, these books are corner-stones for model-driven design

5 comments about Perl Cookbook.

1. Very useful, well worth it. Getting a book like this and having it save you the time of working out how the (yes, come on, admit it, a lot of perl syntax etc. is quite arcane) actual program should be set out, formatted or whatever, is fantastic. Several times this book has done that for me, so one of the best computer book purchases I have ever made.



2. yummy perl recipes; easy to prepare! very helpful for working with date and time data.



3. Most O'Reilly Perl titles imply you'll learn something useful. Only Learning Perl and the Perl Cookbook fully come through in that regard.
   
   The Perl Cookbook features some very practical solutions to some very practical problems (in Perl).
   
   I find myself coming back to this one again and again - more so than Learning Perl, Programming Perl, Programming the Perl DBI, or Perl Best Practices. This is The One. The book to use to learn the Right Way to perform quite a large number of useful functions or tasks in Perl.



4. Your first book on PERL should be "Learning PERL", now in its second edition. It takes you through the basics of PERL in a crystal clear fashion with lots of explanations, exercises, and examples. This should be your second book after you've learned to speak basic PERL. When you want to know the most efficient way to approach specific problems, no other book beats it. A concurrent purchase should be Programming PERL. That book is the definitive book on the language, but you could no more learn to program in PERL from that book than you could learn to speak English by using a dictionary as your textbook.
   
   Spread over five chapters, the first portion of this book addresses Perl's basic data types. Chapter 1 covers matters like accessing substrings, expanding function calls in strings, and parsing comma-separated data. It also covers Unicode strings. Chapter 2 tackles oddities of floating-point representation, placing commas in numbers, and pseudo-random numbers. Chapter 3 demonstrates conversions between numeric and string date formats and using timers. Chapter 4 covers everything relating to list and array manipulation, including finding unique elements in a list, efficiently sorting lists, and randomizing them. Chapter 5 concludes the section on basics with a demonstration of the most useful data type, the associative array. The chapter shows how to access a hash in insertion order, how to sort a hash by value, how to have multiple values per key, and how to have an immutable hash.
   
   Chapter 6, includes recipes for converting a shell wildcard into a pattern, matching letters or words, matching multiple lines, avoiding greediness, matching nested or recursive patterns, and matching strings that are close to but not exactly what you're looking for. Although this chapter is one of the longest in the book, it could easily have been longer still since every chapter contains uses of regular expressions. It's part of what makes Perl the language that it is.
   
   The next three chapters cover the filesystem. Chapter 7 shows recipes pertaining to opening files, locking them for concurrent access, modifying them in place, and storing filehandles in variables. Chapter 8 discusses storing filehandles in variables, managing temporary files, watching the end of a growing file, reading a particular line from a file, handling alternative character encodings like Unicode and Microsoft character sets, and random access binary I/O. Finally, in Chapter 9 there are techniques to copy, move, or delete a file, manipulate a file's timestamps, and recursively process all files in a directory.
   
   Chapter 10 through Chapter 13 focus on making your program flexible and powerful. Chapter 10 includes recipes on creating persistent local variables, passing parameters by reference, calling functions indirectly, crafting a switch statement, and handling exceptions. Chapter 11 is about data structures. Here basic manipulation of references to data and functions are demonstrated. Later recipes show how to create elaborate data structures and how to save and restore these structures from permanent storage. Chapter 12, concerns breaking up your program into separate files. The chapter discusses how to make variables and functions private to a module, customize warnings for modules, replace built-ins, trap errors loading missing modules, and use the h2ph and h2xs tools to interact with C and C++ code. Lastly, Chapter 13, covers the fundamentals of building your own object-based module to create user-defined types, complete with constructors, destructors, and inheritance. Other recipes show examples of circular data structures, operator overloading, and tied data types.
   
   The next two chapters are about interfaces: one to databases and the other to users. Chapter 14 includes techniques for manipulating DBM files and querying and updating databases with SQL and the DBI module. Chapter 15 covers topics such as clearing the screen, processing command-line switches, single-character input, moving the cursor using termcap and curses, thumbnailing images, and graphing data.
   
   The last portion of the book is devoted to interacting with other programs and services. Chapter 16 is about running other programs and collecting their output, handling zombie processes, named pipes, signal management, and sharing variables between running programs. Chapter 17 shows how to establish stream connections or use datagrams to create low-level networking applications for client-server programming. Chapter 18 is about higher-level protocols such as mail, FTP, Usenet news, XML-RPC, and SOAP. Chapter 19, contains recipes for processing web forms, trapping their errors, avoiding shell escapes for security, managing cookies, shopping cart techniques, and saving forms to files or pipes. Chapter 20, covers non-interactive uses of the Web, such as fetching web pages, automating form submissions in a script, extracting URLs from a web page, removing HTML tags, finding fresh or stale links, and parsing HTML. Chapter 21 introduces mod_perl, the Perl interpreter embedded in Apache. It covers fetching form parameters, issuing redirections, customizing Apache's logging, handling authentication, and advanced templating with Mason and the Template Toolkit. Finally, Chapter 22 is about ubiquitous data format XML and includes recipes such as validating XML, parsing XML into events and trees, and transforming XML into other formats.



5. If you are beginner to expert, this helps with simple methods that are tried and true. I find it most helpful in giving me ideas of how to address problems far beyond the scope of the book. Sometimes just simple reminders of cookbook methods stimulates thoughts in orthogonal directions that yield the best solutions to customer problems.

5 comments about Pro ASP.NET 2.0 in VB 2005 (Expert's Voice in .Net).

1. I was looking for a solid, comprehensive, yet approachable ASP.NET 2.0 book for a long time when I stumbled across Pro ASP.NET 2.0. I flipped through it and quickly realized that it is both the learning and reference tool I was wanting. Since getting the book, I have not swayed from that position. This book is a great way to get started and to keep going in your ASP.NET development efforts.
   
   Although large (it weighs in at over 1200 pages), it is well organized and easily accessible. The material builds on itself in such a way that you don't need to read the first 900 pages to effectively use the later chapters. Additionally, the content is organized in a practical approach so you can get started relatively quickly. I find this technique helpful in that it I have more information when it comes time to answer specific questions. I never found myself "wishing" I know more in order to understand a concept.
   
   On the down-side, there are some glaring typographical errors throughout the text. It is pretty obvious in some places that there is a copy/paste error from the C# version to the VB version. None of the errata detracts from the book for me. In fact, in some cases, the little research I did to clarify something actually helped.
   
   All told, I have and continue to highly recommend this book to colleagues and clients alike. It is both an excellent learning tool and a great reference. The fact that one person wrote the entire text and in two programming languages amazes me. The author has an easy writing style that promotes absorbing the information quickly. I anticipate this book becoming tattered quite quickly!



2. I am very pleased with this book. After a couple of failed attempts to find a good ASP.NET 2.0 book I finally found this book. They really did a great job at covering a vast quantity of topics with enough substance that one can actually understand and apply to real life programming situations.
   
   There are some typographical errors and very few examples that don't work but in sight of the great volume of information and examples given, I'd say it is acceptable.
   
   I think I hit a jackpot with this book and I am looking for other books by the same authors that cover more specific topics and I doubt I'll be disappointed.



3. Although this book is only an introduction, the structure and depth are more than fine. After all, to discuss every single thing ASP.NET 2.0 has to offer would require several volume of HUGE books. I would suggest this book to anyone wants to learn ASP.NET 2.0, even with background other than VB.
   
   To the authors, you did a great job!!!



4. I have bought several other books on 2.0 and wish I had discoverd this one first. In each of the different categories, this book is written in order and style to learn and use as a reference. For me, a person with vb6 and asp classic experience this one hit the nail on the head.



5. I am reading this book now for some time. I have worked through the first 5 chapters and I am now in middle of the sixth. The content might be pretty accurate and maybe even comprehensive but there are 4 MAJOR problems which overshadow anything else. They are what I wrote in the title:
   
   A) MISSING: The author almost never starts by stating "add a new class and name it whatever" or "add three textboxes and one label". just throws you something like "heres the complete code" now from the snapshot i am able to figure out how he named the webform, which controls did he add how he named those controls etc. the source code on the Apress site is a must, cuz otherwise you'll be guessing you're head off on every page. Every 2 minutes I'm asking myself:
   should i add a module now? no? maybe soon?
   is this a new namespace?
   do i add that to the previous web form? or is it a replacement?
   is that a table, or div tags?
   other than that he also usually forgets to tell you when a namespace needs to be "imports"ed. probably to leave a challenge to the user why the editor is underlining all the object types.
   
   B) INCONSISTENT: most snippets of code that are more than a few lines will always have some naming conflicts. in line 1 the button is name cmdSave in line 10 it might be cmdSubmit. I mean this didn't happen once or twice it is a constant problem. As i type, i'm indebted to the VB editor in VWD for cathing these booboos.
   
   C) OVERDONE: this might not be a real problem. but as i am not yet such a seasoned ASP.NET 2.0 developer, i find reading pages upon pages of Http pipelines, ASP.NET providers, multiple comparison charts of State management options and custom tracing capabilities before even teaching how to put up a simple data-driven website with simple user and group options, extremely overdone and over comprehensive. if the author wanted to show how much he knows about asp.net 2.0 he could have done so in the preface.
   
   D) THEORETICAL: Everything taught is immediately followed by some code snippet which you could try and figure out where to plug it in and see if it works. he never (so far) builds upon something already done. I am now in the sixth chapter and have a mumble-jumble of techniques to accomplish a variety of odd and end functionality. I haven't the slightest idea of how to build a real world site.
   
   Again, I'm in the sixth chapter only. I'm still hoping to find some useful information in the remaining ones. Just felt I should let people know about it to save them from aggravation.

4 comments about Hunting Security Bugs.

1. I first have to admit to some bias - I wrote the forward, and work down the hall from Tom and Lawrence. So you may want to just read it yourself and see!
   
   These guys really know their stuff. While few people have the fiendish mindset that the authors bring to finding security bugs, the techniques that they lay out in this book will help anyone get very close to the same results.
   
   I've been wanting a book that helps testers as much as Writing Secure Code has helped developers, and it's finally here.



2. If you are looking for a great book to start / or to enhance your library on security this is the book. I was looking for a book that brought depth to the subject but didn't assume that I was an expert already. When I browsed this one in the bookstore, I was impressed that it started off with how you should think about testing your application and what the difference is when it comes to security testing. Funny thing now is that when ever I encounter a situation I think about how vulnerable. Believe me, thats pretty scary.
   
   The authors proceeded to give a logical path for working toward looking at all the areas where an application might be open to an attack. The authors uses thread models to help flush out the design of an application and explains why they are valuable and how to use them. They then get into looking at entry points and point out areas where you might not realize that you have one. They continue with a discussion on how a malicious client and server could be use to comprise your security. Next they cover ways that someone could fool the user into giving up information such as with spoofing and information disclosure, They then get into discussions about techniques such as buffer overflows, stack and heap manipulation, format string attack and script attacks including XML issues. Along with this you'll find information on permissions, areas for denial of services as well as ActiveX attacks. Finally, you find a very good checklist for doing a systematic approach to checking your security. The topics are well written and provide plenty of examples as well as thoughts about how to deal with the topic.
   
   Even if you don't read every chapter there is plenty of information for any particular area that you are interested in. It makes a great book to have on your shelve when you need to brush up or learn about a particular topic.
   
   After reading the book, I contacted one of the authors and asked him to present to my team. Yes, I work at the same company but that didn't influence my decision to buy the book especially since it was my own money going to purchase the book. He consented to giving us a presentation and his talk has inspired my entire team to ask for a copy of his book. Being that I had already read about half of it, I knew what he was talking about so it reinforced my opinion of the book. I would say that is a pretty good indication of how good the book is when an entire team asked for a copy.
   
   You won't be sorry if you purchase this book.



3. As with other reviewers of the book: in an attempt at full disclosure, I also work at Microsoft. I am a Test Lead in the Office organization.
   
   One of the challenges that faces any quality assurance engineer or Test engineer, or whatever our industry has chosen to call us this year is that we are constantly tasked with trying to "test in security" or "find the flaws in the product" after it has already been coded. While this is clearly a PART of our jobs, it is by no means the most important part. This book addresses what I consider to be a much higher priority for the Test Org generally, and Test Engineers specifically: helping reduce security vulnerabilities before they are coded into the product to begin with: as features are being spec'd and as code is being designed.
   This book is not a simple check-list testers can use to say "Yes, my feature is secure, Ship It". Rather, it helps place Test into the frame of mind of a hacker, it gives test a set of tools to help find security issues, it outlines an approach to software Test that will cause fewer security issues to be coded at all, let alone have to be fixed post code-complete (or in a Service Pack). Used in conjunction with other test books like _How to Break Software Security_ by James A. Whittaker, this book will help ship more secure products.
   Incidentally, I expect hackers will be reading this book in an effort to better understand the science of hunting security bugs, as well as the tools we use to do so - so if you're not using it, I'd expect your attackers will be thankful...



4. Beside Bruce Schneier books, this is the second software security book that I am reading. The first being Building Secure Software: How to Avoid Security Problems the Right Way and I have prefered this one because it provides more concrete examples. The book consists of over 20 chapters covering different security areas. As a software developer, some chapters appeared less relevent and less interesting to me and I guess that it is because these chapters are geared principally toward testers. However, at least 2 chapters should be extremely interesting and valuable to developers like myself. It is the chapters that demonstrate with step by step tutorials how a hacker would do to exploit buffer overflow and format string problems. I was already familiar with buffer overflows and I had read a similar chapter about them in Building Secure Software: How to Avoid Security Problems the Right Way but the format string exploits were new to me. As expected since the book is published by Microsoft Press, the book has a strong bias torward Microsoft products (ie.: .NET and ActiveX controls security) but the presented topics are general enough to make this book very valuable even for users of other OSes and/or development tools.

2 comments about Developing Distributed and E-Commerce Applications + CD (2nd Edition).

1. This book was written as a college-level text. It also targets IT professionals who need to quickly understand the differences between e-commerce applications and traditional information systems as a secondary audience.

   As a college-level text this book is one of the few that will prepare students for the real world. The scope of topics, level of detail, and carefully chosen case studies are impressive because they capture the key knowledge areas and issues that working professionals deal with.

   As a refresher for working professionals who need to understand the big picture and intermediate details associated with e-commerce applications this book's wide coverage of topics makes it ideal. While students will need to work through the entire book, an IT professional can choose the topic areas selectively. For example, the chapter on E-commerce applications that covers supply chain management, e-tialing and auction sites will have more appeal to a working professional, while the chapters on programming will probably capture a student's interest.

   Additional features that will be of interest to each audience include:

   - Students and Instructors: (1) CD ROM that comes with the book contains exercises, source code, and additional study material, (2) a companion web site that provides 296 PowerPoint slides that augment the course, and (3) links to over 750 web sites that reinforce the lessons.

   - Working professionals: the CD ROM that comes with the book contains the full text of the book, which will allow searching for any topic or keyword. This is an excellent research resource, that is all the more valuable since the book is up-to-date and covers current technologies (Java, relational databases, XML, etc.), as well as important business issues.




2. Every thing was done professionally, I am complete satisfied with the service I recieved.

4 comments about Computers as Theatre.

1. Laurel is quite the scholar - she's got experience and learning in the fields of theater and human-computer activities. Laurl applies Aristotle's Poetics to computer software design. I especially liked her comparison of computers to theatrical production - a tremendous amount of action goes on "behind the scenes." As Laurel points out, dramatic expression is a type of virtual reality; anything we develop with computers has a very long heritage. A must-read for the digerati



2. I finished reading "Computers as Theater" by Brenda Laural yesterday. The book has many good ideas in it, and it may well be worth reading just to pick these up.

   It is also one of those books which does not do a good job of unifying its material, in my opinion. Rather than being a progression of ideas that builds to some intellectual climax, it meanders through various interesting points not quite aimlessly. The book introduces two useful diagrams: 'flying wedges' which describe how the space of possibilities in a drama go from the 'possible' to converge on the 'necessary', and 'freytag triangles', which measures the rise and fall of a plot. If these are used to describe this book (a slight abuse?), it doesn't fare well. The freytag diagram never peaks, and the wedge doesn't converge to the 'necessary'. This may be because the objectives for the book were not clear. As a reader, I didn't realize she was not (mostly) speaking to the modern commercial software world for quite a while into the book. The book also ended with two chapters about virtual reality (the substance, not the hype), and I was left wondering if perhaps *this* was what the book was really about (if so, I didn't see it coming).

   All that said: there are many good ideas in the book, some of which will make you stop and think for a while (e.g. those diagrams). It is valuable because of this. As an individual, I simply wish the book had been better structured, for I'd have gotten more out of it.




3. ... because it reminds me a great deal of Bruce Lee's "Tao of Jeet Kune Do." In that book, the reader is warned in the preface to approach the book actively with pencil in hand to jot notes and draw lines between connected ideas. I have done this with Brenda's book. It will take about 6-7 reads and lots of mental connections before everything starts to gel.

   It is a new "Way" of thinking, and, indeed, is so far ahead of any way we design software now that many ideas that this book suggests still need extensive research to even understand how to implement. (e.g. Freytag graphs as a way of structuring software/task flow to provide a pleasing HCI, and Brenda's Principles of Intelligent Computer Agency as a means for implementing truly AI agents with personality and emotions).

   Along with the wonderful head rush of compelling new theory, she also takes the second half of the book to explain principles of software design that you can implement in your programs _now_, and also takes the time to introduce you to fascinating HCI research offshoots like Programming by Demonstration.

   It is wonderful writing, and her ideas and concepts continually refresh and remind me why I am in such an exciting field.




4. The idea that is perhaps most central to this book is that if you design the action involved in a user interface, the design of all other objects in the domain will follow. To support this, Laurel reconciles the seemingly disparate and relates user interface design with producing a play in theater. For example, the way she brings in the Freytag triangle works very well.

   This said, I wish I wish that we would see a book from Laurel (or from one of her other usability guru companions) that treats with more recent issues-- particularly the Internet. I think she's one of the smartest people out there in the field, and I try to read what she's written, but I'm getting tired of reading about Habitat, Guides, and the Holodek on Star Trek. That's not the fault of the book, given that it came out pre-Internet hype, but it did inflect the reading experience with some weariness.

No comments about iPhone in Action: Introduction to Web and SDK Development.

3 comments about Domain-Specific Development with Visual Studio DSL Tools (Microsoft .NET Development Series).

1. There's no doubt that Microsoft has a steller team working on its DSL tools, and given their position on the DSL team, there's no better team of writers to elaborate both the underlying concepts as well as go in depth on the implementations of those technologies in the Visual Studio DSL Tools.
   
   The more developers and architects getting familiar with DSLs and modeling, the better, and this toolset and book are the best resource I know of for learning more about the domain and getting a very useful and concrete example of the concepts as well as a tool you can use to start building your own.
   
   Buy it. Learn it. Use it.



2. The books covers almost all of the capabilities for the DSL world, however in this approach to cover all themes, they present some important subjects in a very light way. The reader must have a previous and seriuos knowledge of DSL items and a lot of experience in Visual Studio 2005.
   However some chapters (2,3,4,8 and 9) are very very good :D



3. I am disappointed, because the writers are the top of Microsofts engine driving domain specific languages.
   The book tells what is possible using Visual Studio 2005 and the DSL tools. However it does a terrible job in explaining how and when to use the tools.
   It is not a handsone book, you can't take it and work through examples and it is not an reading/theoratical book either, you can't read it while one the train to work and hope to learn anything.
   Just like the book on software factories this book is elaborate and the writers are smart they are just not capable of making the information simple and interesting enough to stick into my head.