5 comments about Designing the User Interface: Strategies for Effective Human-Computer Interaction (4th Edition).

1. This is more of a syllabus with references than an actual textbook. It's even a sensible syllabus; if you want an outline of the important topics in contemporary and historical computer user interfaces, Shneiderman's book will tell you what you need to know. But the utility of this book is unclear; it's not intended to teach the reader how to design interfaces, nor does it teach experimental design and evaluation.

   At 600+ pages, it's both terse and verbose. Verbose, because of the "let me tell you what I'm going to tell you, tell you, tell you what I've told you" format favored in this kind of overview. Terse because the "tell you" part is a kind of white-washed summary; as soon as a topic is brought up, several references are trotted out, summarized in one or two lines, and then dismissed. I wanted more depth, more case studies, and a higher-level vantage point.

   Despite a short tour of command lines, including natural language text commands, and a 10 page summary of speech recognition and synthesis-based interfaces, "Designing the User Interface" is almost exclusively about contemporary computer graphical user interface design. Better books on GUI design include Johnson's "GUI Bloopers" and Raskin's "The Humane Interface".




2. As most reviewers have noted, this is a classic and must-have book in the field of HCI. This fourth edition--newly published in March 2004--has been thoroughly revised to include much material related to the WWW. It does appear that Shneiderman took care to go through each chapter and remove less relevant material in favor of including new topics that have come up since the last edition was written.



3. This book looks more like a collection of references than a real text book. The author inserts references to other works and papers in such a random and repetitive fashion that makes reading the book a real pain in the ass.
   
   And then there is the verbosity. Apparently, Mr Shneiderman likes to list items and give examples. And he likes it a lot. If you make the terrible mistake of reading this book you will navigate through never-ending paragraphs that make circles and circles around the same idea, giving pointless examples of an anyways pretty obvious concept.
   
   This book is really bad. It looks like the author just copy-pasted the contents of his course slides and inserted some pretty pictures in the middle. Don't waste your money and/or your time with this one.



4. No other book in the field of HCI (Human-Computer Interaction) is as broad, has so many useful guidelines and is a better bibliography as Shneiderman DTUI (Designing the User Interface).
   
   DTUI will *not* give you in-depth knowledge of every aspect of HCI, because that's an impossible task for a single book.
   Instead, DTUI focuses on giving you an overview and understanding of central HCI concepts coupled with useful everyday tips, rules and guidelines.
   
   The passionate HCI student will in DTUI also discover a comprehensive guide to the books and articles that have shaped HCI throughout the years. (Reading the HCI body of work, you will soon discover than DTUI is one of the most cited books in the field, an indication of how influential it is.)
   
   To teachers in search of a introductionary HCI book for their classes, I strongly recommend DTUI. "Interaction design" by Jennifer Preece, et al. is another fine book that's has less theory in favor of the practical.



5. Book is very well written, and covers all the topics necessary and with the necessary detail to grasp the concepts related to human interface design. Highly recommend this book to anyone!!

5 comments about Software Architecture in Practice (2nd Edition) (SEI Series in Software Engineering).

1. Some would have trouble describing the discipline of Software Architecture in a concise sentence... Writing a book about it is a bigger challenge.
   
   What I like about this book is that it spells out succinctly some of the principles that software architects should adhere to... and then identifies why they sometimes should not. The tradeoffs, while not discussed in the light of a common problem, but mostly as a comparison between two or more 'reference architectures', become clear once the reader can frame the problem in a way that applies to her own architectural dilemmas.
   
   On the other hand, the book now shows its age. While CORBA makes for a good case study, most software architects would benefit from a Web-Services study, and the patterns that are being used there.
   
   Overall, a good book but I would recommend you flipping through it to figure out if it would help you in your day-to-day activities - or whether another Software Architecture book is more suitable.



2. What is arguably the best analogy to the creation of the large, modern software product is the construction of the great pyramids of Egypt: any error made in laying down the lower layers was magnified many times over when the additional layers were added. The placement of even a single component required the coordinate actions of many workers. Large detailed plans were necessary before the first block could be laid and while no precise deadline existed, there was a general one. Finally, despite their impressive size, the pyramids were built by applying simple components while following a well-understood pattern for integration.
   Therefore, as so many people are now pointing out, software engineers can learn much from the masters of construction.
   Architecture (architorture to students of the craft) is a very difficult area to master. The human mind processes information based on patterns, but much of that efficiency is based on experienced patterns, and abstractions rarely come easy even to the prepared mind. In this book, the authors do a great deal to assist "open minds" in preparing to understand and use architectural patterns.
   To present their ideas, the authors coined the phrase, "Architecture Business Cycle" (ABC). This phrase is designed to describe the entire process, from the initial itch on the back of the brain, to the influence of the architecture of one product in succeeding generations of products. Only when the consequences to future generations of software are included can we truly say we are describing the complete software life cycle.
   The approach used is a combination of explanation and case studies. Seven of the nineteen chapters are case studies that generally are well-done examples of the material. The core of the book, however, is the development of the steps in the construction of the ABC. The first step is the creation and analysis of a specific architecture. To perform the analysis, the authors put forward the Software Architecture Analysis Method (SAAM), a scenario-based method of evaluation. This technique is also one of the components of an architecture-review process.
   After the architecture is developed, it is time to create an equivalent system based on the design. To do that, a symbolic notation is needed. While there is some time spent on Architecture Description Languages (ADLs), this is one topic that should have been expanded. Without a common language that has a high degree of precision, there is a great deal of room for potential error. The analogy or metaphor that clarifies a concept for one person makes it less comprehensible for others. An example of an ADL is presented, but seven pages containing diagrams is not enough to do more than spark interest or confusion.
   The final area concerns the reuse of components and architecture. Two chapters are devoted to this topic, one on reuse within an organization and the other on reuse within the community. Within an organization, the emphasis is on the other software product line-a series of products in both parallel and sequential development. Creating a "reasonable" match to a consumer's requirements in the software development equivalent of real time is achievable only if there is an extensive stock of well-designed components that work and play well with each other. The only way to achieve this is to make such behavior part of the fundamental design. In the modern era of global competition, exposing your architectural designs to the world might seem to be a poor business practice. However in many areas this is not the case.
   Software developers can learn a great deal from the construction engineers of the ancient world. When planning a complex structure, the medieval architect commonly attacked the problem from a multigenerational perspective. Knowing the project would not be completed for decades, the initial architectural plans included the passing of the necessary legacy knowledge down to the later generations of planners and builders. Only then could there be a guarantee of completion and long-term viability. The ABC as put forward in this book is one way the computer industry can approach problems from the same perspective.
   
   Published in Journal of Object-Oriented Programming, posted with permission.



3. This book is great to gain theoritical knowledge about software architecture, but it lacks practical insights. May be it's my specific problem, because I was trying to find a good book on architecture of web applications, which this book does not provide.



4. This text is chock full of "Case Studies" in Architectural design & development methods, but surpringinly sparse in specifics. The authors' take an approach that is almost entirely qualitative; I was hoping to see a more analytical set of methods for analysing architectures, but found little.



5. This is a solid work on SEI's ADD methodology. The authors fully document the ADD methodology in terms of incorporating this into your practice. Clear text, diagrams, and illustrations depict how you bridge the gap between theory and practice.
   
   If you're looking to use, or enhance, how to leverage your use architecture, I recommend this book. ADD is a method that values the business intent of the software, and constructs a method that delivers value to the customer.
   
   There are some weak chapters, which prevent me from giving a 5-star rating. For example, Chapter 10 addresses reverse engineering an architecture. The focus was on a point exercise that is not useful in either theory or practice. Other case studies in the book (there are a few) were not helpful as they did not have the keys to turn the theory into practice. For example Chapter 16 addressed a J2EE/EJB study; however it was very high-level and omitted important details to be used in practice. However, the case study of an avionics system (Chapter 3) was good; it provided insight in how to apply theoretical concepts.
   
   I recommend this book for those organizations looking for a solid value-add approach to improving your architectures both technically, and in customer value.

5 comments about Rails Cookbook (Cookbooks (O'Reilly)).

1. Web programmers and practicing developers working with Rails will want this solution-oriented guide to building web 2.0 applications - a guide packed with recipes for success from the basics of installing and using Rails to the latest applications. Learn how to work with an application's logic, how to test and debit a Rails application, and use Rails plug-ins with RAILS COOKBOOK: APPLICATIONS FOR RAPID WEB DEVELOPMENT WITH RUBY, which covers version 1.2 and will reach both programmers and serious programming libraries.



2. Probably my most worn RoR book. It doesn't teach you Ruby or Rails since it's really a how-to book. I learned Ruby and Rails from other books but once I set out to build an app, I often thought to myself "now I remember reading about this somewhere, I just can't remember the syntax." Instead of digging through my other books, I thumbed through the TOC and quickly found a refresher. Well worth your money and saves you a lot of time spent on google or searching for solutions in other books.



3. Now that I've encountered a few recipies books, I have to admit I'm in love with the format. I proves very practical and much easier to use.



4. The "Rails Cookbook" is a very useful book for the working programmer.
   
   Programming is all about solving problems, and that is exactly what this book is about. Each "Recipe" contains the problem, the solution and a discussion about the solution. They are concise without being too vague to be useful.
   
   The book contains almost 200 of these problems / solutions.
   
   This probably wouldn't be a good introduction to the language or the framework, but if you already are familiar with both - this book is a very valuable tool to help you get your work done.



5. I used this book for a grad class project that had to do with building multimedia database system with Ruby on Rails framework. This is the first of the "cookbook" series I ever purchased, so I was a bit skeptical in the beginning. I am very pleased with this book. It has detailed solutions for several of the common problems. I had successfully built a nice multimedia database driven application in a single weekend with this book. Code examples are well presented and it's easy to incorporate it into your application. This is not a beginner's book. If you know nothing about Ruby or Rails, you should get a beginner's book first - I used "Build Your Own Ruby On Rails" by Patrick Lenz [note that this book is available for free download on the web - search for it on Google]. I am very highly pleased with this purchase and I will recommend it highly especially to those who want to get up and running quickly.

4 comments about The Book of Qt 4: The Art of Building Qt Applications.

1. I recently had to translate a C++ application from the now defunct Borland C++ class libraries to QT4, so I had some on-the-job training with QT and was very impressed by the elegance and depth of Trolltech's design. But I needed a general book to round out my knowledge, and this book filled the gaps well. It's well-written and clear.
   
   Also hats off to NoStarch press. It's a beautifully designed book, which makes reading a good book even more of a pleasure.



2. I've just started to look at this book. It appears to have the information I need about QT4.



3. 
   The Book of Qt4 is an excellent recommendation for any interested in using QT to build GUI applications, and for advanced computer libraries catering to programmers and designers. Chapters cover all the tools for creating dialogues, data visualization techniques, handling databases and events, and more, offering tips on developing user-friendly applications and providing black and white screen shot examples throughout. It's an excellent guide for any QT programmer, and for collections catering to them.
   
   Diane C. Donovan
   California Bookwatch



4. This book is a fairly standard tutorial on building user interfaces. It covers the basics, and should be sufficient to get most C++ programmers up to speed. However, there are quite a few points in the book where the author hand-waves his way through a process. This can make following the tutorials somewhat confusing and gets in the way of the general understanding of the process. In addition, either because of platform differences or poor testing, some of the examples do not work properly. For example, in the cuteedit2 example in Chapter 4, the buttons for the discard changes dialog have their meaning reversed. On the surface it is hard to tell if this is a bug in the book or in the OS X implementation of QT 4. Finally, many key ideas a mentioned almost in passing (like the use of the tr() function to aid in translations), making it imperative to carefully read every word.
   
   This text pales in comparison to the Hillegass text on Cocoa programming, which could be considered the gold standard of UI programming tutorials. In general, you will be able to get yourself started on Qt programming with this text. However, the lack of quality control will make the experience a little less pleasing than it otherwise could have been.

5 comments about lex & yacc.

1. This book is a little out-dated. That is fine, though - this book goes over all the essential proponents of Lex and Yacc and Bison and FLEX and all the other variations ... which you will certainly know a lot more about by the end of this book. This books enabled me to read FLEX input from a c-string, which has played a role in a few of my projects. It is great when you just need a quick reminder of the syntax is the tools. This book does not go over how the programs work, which is a good thing, because that would make the book more oriented towards Finite Autonoma and Context Sensive Languages - leave that sort of thing to autonoma theory and compiler design. This is an excellent reference, so buy it if you really need it.



2. Yacc (yet another compiler compiler) and its companion lex (lexical analyzer) are primarily intended to allow quick and easy development of small special-purpose languages. The common mistake is assuming that they are only useful for creating compilers for massively complex eccentric languages. This is not the case, though you could no doubt use them for such a purpose.
   
   Lex and Yacc are commonly used together. Yacc uses a formal grammar to parse an input stream, something which lex cannot do using simple regular expressions since lex is limited to simple finite state automata. However, yacc cannot read from a simple input stream - it requires a series of tokens. Lex is often used to provide yacc with these tokens. As a result, building an application in lex and yacc is often used as an exercise in classes on programming languages and the theory of computation to demonstrate key concepts.
   
   The book starts out building a simple character-driven calculator, and then moves on to build a menu generation language that produces C code that uses the standard "curses" library to draw menus on the screen. The final application is a SQL parser which includes a quick overview of both relational databases and SQL. Some readers will dislike the fact that Lex and Yacc are only capable of generating C code. Thus, the logical conclusion is that you must be able to write C code in order to use these tools. While it would be nice if the sections about the menu generation language and the SQL parser had some information about how to do typechecking and other such things, this book is not about writing a compiler/interpreter using Lex & Yacc. Rather it is just a beginner's guide.
   
   The sections about shift/reduce and reduce/reduce conflicts are especially helpful, as are the sections going over the differences and caveats relating to the major versions of lex and yacc such as AT&T's Lex & YACC, GNU's Flex & Bison, and Berkeley's Yacc. In summary, if you've never used lex or yacc before and think they might be useful tools for you, and you already know the C programming language, this is a handy book to have.



3. To me a great book flows into your mind, magically providing the information in the order you need it. Of course it depends on whose reading it, but this book, though well worth the 96 cents bargain bin price I paid for it, does not build the constructs in my head the way I'd like.
   
   Authors should always proofread their books with novices, not the experts. Experts fill in the gaps as they read and don't notice if the logic is missing a link. In chap 2, "Using Lex", there is the sentence: "Lex itself doesn't produce an executable program; instead it translates the lex specification into a file containing a C routine called yylex(). Your program calls yylex() to run the lexer."
   
   I waited with baited breath for what it means to "run the lexer". Does it return a token each time you call it? Does it analyze all the input then return? The text ignores this detail and merrily goes on into other details. The chapter is called "Using Lex", but the authors omit how you use it! Of course you can scrounge around in the examples and finally root it out, but a book should paint a crystal clear picture, get you oriented, then drop in the details to build your understanding.
   
   The book looks so promising, sort of like the beauty of the original "The C Programming Language" by Kernighan and Ritchie, but disappoints in it's fragmented exposition.
   
   I did take a compiler course with the "dragon book" years ago and write a parser, so I'm not totally in the dark, but I expected this book to lay the subject out in a much clearer way. But it is still a good book to have and read "offline".
   
   I hope the authors take a crack at another edition and explain it all better.



4. I like this book because it is a good compromise between lex & yacc man pages and the theory found in books such as the Dragon book. You will get valuable information about the how and why of the tools that will help you to produce a quality grammar without being overwhelmed by details.



5. This item is a definite must for coursework dealing with scanning and parsing. I thought that I would be fine if I just relied on web sources to assist me in Lex assignments, but as a deadline approached and I still had no results I turned to this book. The content is clear, concise, and absolutely fantastic. If you want to know how to work with Lex and Yacc, this is the book you need.

3 comments about Managing Projects with Microsoft Visual Studio Team System (Pro-Developer).

1. In Managing Projects with Microsoft Visual Studio Team System, Joel really gets to the heart of addressing the reasons and benefits of having a common set of application lifecycle management tools (Visual Studio Team 2005 System) for all participants in the software development process to effectively track and report on individual and team progress.
   
   It's not just the tracking and reporting, but its the metrics provided that allow answers to questions such as:" What percent complete are we at for this development project?; What's the overall software quality measurement?; How much more time is required before we are done?"
   
   Not only does Joel discuss the problem of inter and extra-team communications for reporting on software development projects, he provides practical advice, examples and guidelines on how to implement and use Visual Studio 2005 Team System to orchestrate the communications and reporting processes for all roles (project manager, architect, developer, tester, sponsor, etc.) in the software development process.
   
   A must read for anyone that manages Visual Studio.NET software development projects and wants to increase the effectiveness of their development efforts!



2. This book helped me with ideas that put in practice, provided new ideas of as it manages projects with VSTS. For me it was useful.



3. This book provides a good overview of VSTS. It goes into enough detail that the reader understands the broad range capabilities without being overwhelmed. If you just want a reference on VSTS, then I recommend this book.
   
   However, the book is just plain lousy when it comes to the process of managing an actual project. Firstly, PMBOK stands for "Body of Knowledge" not "Book of Knowledge". Secondly, the importance of gathering, analyzing, validating, and verify requirements is woefully under-represented. Quality is mentioned, but in such a cursory way as to be practically useless. Ditto on CMM - not enough detail is given on key processes and work products. The process here seems focused on building software without first determining what to build or checking the correctness of what was actually build.
   
   The approach here might work on small greenfield projects, but would be a train-wreck on any large project with involving any degree of human safety, legacy systems, accountability, etc. In other words, the project management approach in this book is probably not suitable for 90% of projects in an enterprise IT environment.

5 comments about Foundations of Python Network Programming (Foundations).

1. Apress has two books on Python that I really like. This one and "Dive Into Python". The thing I like about this book is it delves into some deep concepts, like client/server code, but does so in such a way that even people new to Python should have no problem understanding it.
   
   I have been a programmer for about 15 years, and made heavy use of Python for the last 5 or 6 years. My brother is new to programming. Both of us found this book to be very useful and easy to understand. I recommend it to programmers of all levels.



2. This is a well presented, well paced introduction to network programming in Python. He presents programs both as interactive sessions (follow along in the comfort of home) and as scripts (programs) available to download from his web site at Apress.
   
   It serves as a good, general purpose, introduction to network programming as wall as a Python-specific network programming tutorial.
   
   I do, however, have some complaints. Although the author attempts to present information in a platform-neutral manner, it is obvious that he is much more familiar with *nixes than with Windows. There are several minor factual errors in the Windows information he presents. [I have submitted these as error reports on the Apress web site.]
   
   Fortunately none of these disrupt the actual presentation. Experienced Windows programmers will be able to correct the mistakes on-the fly. As a minor example, Windows programmers know they can type "script.py" to run a python program even though Windows doesn't honor the #! line at the beginning of the script.
   
   My other complaint has to do with the use of PyDNS to discuss DNS issues. As far as I can tell PyDNS is dead, or at least it is dying. dnspython would have been a much better choice. However given that the book is three years old, I can't really fault the author for picking the wrong package -- it's happened to all of us at some point in our careers.
   
   And a truly minor quibble: he starts with an example of downloading a file using the gopher protocol. Do you have any idea how hard it is to find a gopher server now days



3. It has everything you need to know about Networking Programming in Python. Easy to understand also. It can be made more detail and more advance for profesional use.



4. I'm giving this book 5 stars because I found it more useful than many books. There are some flaws, but overall I am happy that I own this book.
   
   This book uses a teach by example technique as discussed in other chapters. It is oriented towards application developers that find themselves in need of python networking rather than networking people that need python.
   
   The book is overall clearly written and the examples are generally interesting. The author shows an advanced understanding of most of the subject matter. Chapter strength is fairly variant. On the other hand, it's pretty likely that you do not have knowledge of all the topics in this book and will learn something interesting by reading it.
   
   Cons: The chapter on HTML tag matching felt really weak. They tried to treat HTML as a regular language by using state machines to match it, when it's clearly context-free, then he started to add a stack but he had already lost my interest as the examples got fairly unwieldy.



5. I have no background with Python and limited understanding of networking. So my comments are from a rookie. So here they are:
   
   1) Readable: technical enough but gets right to implementable examples. You can jump around in the book and find what you need with out having to read the whole thing.
   2) Applicable: I used examples from the book to gain an understanding of my Linux system and my home network.
   3) Python is free so use it.
   
   That is all.

5 comments about .NET and COM: The Complete Interoperability Guide Parts A and B.

1. This book has been an invaluble resource on a .NET/COM interop project I've been working on. Don Box's quote on the cover sums up the title nicely, "This is the last book that should be written about COM programming. There is nothing left to say."
   
   Since I'm a published author myself, I first bought a book on this topic from my publisher Microsoft Press. While accurate, it left a lot to desire. Very little advanced information was provided. However, this title from Adam Nathan's and Sams Publishing leaves nothing out, including extensive references.
   
   If you are working with COM objects from .NET, or vice-versa, this book will be an excellent resource.



2. Never one to skimp on books, I ordered three with almost exactly the same title on COM/.NET Interop when I needed some information on the subject. Adam Nathan's book is by far my favorite. I've never found an answer in another book that wasn't in Nathan's (and have found many in his that I didn't find anywhere else).
   
   It seems like this book isn't as easy to get on amazon as it once was--a pity, because it's the first (and maybe only) Interop book you'll need. Maybe he'll come out with another edition as .NET changes...



3. I read Troelsen's book on COM/.NET interroperability. This two volume set easily exceeds in content. Both books provide valuable information that I use regularly in developing .NET solutions that use COM as clients and servers. If I had to have only one selection, I would choose these books (Adam Nathan's) for the extensive content.



4. My co-worker had a previous edition of this book (now set) and it was the bible for any question regarding .Net/COM interop. When he left the company and took the book with him I was sad. Now it's back in print, however, and happy days are here again.
   
   I'm not going to pretend that I'm a COM God; I'm mostly a desktop .Net component developer who has to expose the component to both managed and unmanaged (COM) clients. This book was invaluable for walking us through some of the trickier steps of integrating our new component with the main client (QuickBooks accounting software) in a way that supported new version deployment and backwards compatibility.
   
   The way that Nathan describes best practices for exposing managed libraries to COM is clear and concise (as much as you can be when talking about COM, I suppose). It directly led to several utilities and build steps we added in order to create better components.
   
   I highly recommend this book set.



5. This product requires some knowledge and experience in coding with .NET and in Visual Studio but it contains all you need to know about the interoperability of .NET and COM. Many hints, detailed information and examples are included and guide through the interoperability of managed and unmanaged components.

No comments about The Definitive Guide to SOA: Oracle® Service Bus, Second Edition (The Definitive Guide).

4 comments about Beginning ASP.NET 2.0 Databases: From Novice to Professional (Beginning: From Novice to Professional).

1. Almost every book with ASP.NET 2.0 in the title will tell you something about the Grid View, Detail View, Form View, SQLDatasource and the SQL 'Select' statement; this one will too. While the other books provide a rudimentary overview of these topics then move on, "Begining ASP.NET 2.0 Databases: From Novice to Professional" takes you way beyond the SQLDatasource and the 'Select' statement, delving deep into ADO.NET.
   
   Just as bread & butter go together ASP.NET and databases go together; and there is a lot more to the database side of the equation than is brought out in most ASP.NET books, which tend to limit themselves to the use of the controls, getting into databases only enough to have something to show in the controls. with this book it is the other way around; the reason for the controls is to display and maninpulate data in a database, and there are several ways to access and manipulate databases with ADO.NET besides the SQLDatasource. Along the way you will learn to use the controls with all the different data access formats and how to use the controls and their events to manipulate the data, which is what it's really all about.
   
   If DataReader, Command Object, DataSet, OLEDBDatasource and ODBCDatasource are not familiar terms to you, and you want to develop ASP.NET web sites you need this book. If you don't know when not to use the SQLDatasource (there are some definite situations when it won't work), or don't know how to create a server side data cache and why you would want to, you need this book.
   
   The book is easy to read and has numerous small exercises titled "Try It Out", after each exercise is a "How It Works" section where the code in the previous exercise is explained, line by line in most cases. Not only does Damien take you through DataReader, Datasets and Commands he also covers stored procedures, which you will want to use rather than queries in code shown in most of the other books.
   
   While the book primarily uses SQL Server 2005, MYSQL 5.0 is also covered at the same time, everything from installing and configuring to using with stored procedures, parameters and transactions.
   
   If you want to build ASP.NET web sites you will work with databases, if you are not intimately familiar with ADO.NET this book should be on your bookshelf readily available.



2. I really liked this book because it shows step-by-step how to do things and then has a "How does it work?" section. Great book! Well written and seems quite comprehensive.



3. This book does a good job explaining how to work with databases. The one thing I didn't realize is the only language used for examples is C#. It would be nice if VB examples were also included.



4. I bought this book knowing a good bit about regular ASP and how to communicate with databases, hoping to learn how to do the same thing with ASP.NET. I was not disappointed. The book walks you through step-by-step in creating database connections, command objects, stored procedures, etc... It doesn't dwell too long on topics that it shouldn't be covering (like database design, and web site design). The instructions within the book identify software that is free, so there are no unpleasant surprises. This book will be a great reference and has really helped me make the jump from ASP to ASP.NET.