Beginning Active Server Pages 3.0 / Edition 3

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 95%)
Other sellers (Paperback)
  • All (37) from $1.99   
  • New (5) from $7.90   
  • Used (32) from $1.99   
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any coupons and promotions
Seller since 2009

Feedback rating:



New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

2000-01-01 Paperback 3rd New 1861003382 Ships Within 24 Hours. Tracking Number available for all USA orders. Excellent Customer Service. Upto 15 Days 100% Money Back Gurantee. ... Try Our Fast! ! ! ! Shipping With Tracking Number. Read more Show Less

Ships from: Bensalem, PA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Seller since 2015

Feedback rating:


Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Seller since 2010

Feedback rating:


Condition: New

Ships from: Philadelphia, PA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Seller since 2014

Feedback rating:


Condition: New
PAPERBACK New 1861003382 XCITING PRICES JUST FOR YOU. Ships within 24 hours. Best customer service. 100% money back return policy.

Ships from: Bensalem, PA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Seller since 2015

Feedback rating:


Condition: New
PAPERBACK New 1861003382! ! KNOWLEDGE IS POWER! ! ENJOY OUR BEST PRICES! ! ! Ships Fast. All standard orders delivered within 5 to 12 business days.

Ships from: Southampton, PA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Page 1 of 1
Showing All
Sort by


Beginning Active Server Pages 3.0 is aimed at two distinct groups of developers. First, it addresses the needs of the HTML programmer looking to progress to the next stage -- to create dynamic web pages and understand how to structure a site for future growth. Second, it assists developers switching to Windows 2000 -- because it outlines all the changes and explains ASP from the standpoint of IIS5 and the new user interface.
Read More Show Less

Editorial Reviews

From Barnes & Noble
This is a comprehensive tutorial and guide for programmers and developers. Active Server Pages 3.0 (ASP) is a powerful server-based technology and an integrated component in Windows 2000. Along with XML, ASP is Microsoft's web development future, geared for the development of dynamic, interactive and scalable web-based applications. This publication follows the same style and format as its popular predecessor Beginning Active Server Pages 2.0, but includes the latest features and enhancements incorporated in version 3.0 of ASP. Please be familiar with object-oriented concepts, web document development and HTML. It will help to know VBScript, but the book does contain a quick VBScript tutorial.


  • Introduces dynamic web page concepts, shows how to write your first ASP example, then dives into basic ASP techniques and server and client side scripting concepts.
  • Shows to create and declare variables and use ASP control structures.
  • Details objects, properties, methods and events.
  • Explains how to handle request and response objects, errors, applications, sessions and cookies.
  • Covers scripting objects, ASP components and data store access, recordsets and advanced data handling techniques.
  • Introduces the Wrox Classifieds Application, shows how to build script components, and explains transactions as part of the COM+ framework.
  • Presents the Extensible Markup Language and shows how to create documents.
  • Make no mistake, this thorough and comprehensive ASP tutorial is for web programmers and developers, not casual coders. Just like its predecessor, it is packed with solid information, diagrams and code needed by developers.
  • The thirteen appendices contain additional information, ASP & ADO object models, forms, error codes and references.
  • Information and support is available on the associated web site.
Related Titles:

Once you master beginning ASP programming concepts, you will be ready for Professional Active Server Pages 3.0. You may also be interested in ASP guides and references for specific technologies such as Beginning ASP Databases, the sequel Professional ASP Databases, or the excellent supplement Beginning Components for ASP. Sooner or later you will also need to use XML. Any number of beginning tutorials are available, but there are a number of good advanced guides and references for programmers. Two excellent examples are Microsoft XML 2.0 Programmer's Guide and Software Development Kit and Designing Distributed Applications with XML, ASP, IE5, LDAP and MSMQ.

Reviewed by RD - February 2, 2000

Read More Show Less

Product Details

  • ISBN-13: 9781861003386
  • Publisher: Wrox Press, Inc.
  • Publication date: 12/1/1999
  • Series: Beginning Ser.
  • Edition number: 3
  • Pages: 1199
  • Product dimensions: 7.25 (w) x 9.14 (h) x 2.06 (d)

Read an Excerpt

This manuscript is an abridged version of a chapter from the Wrox Press book Beginning Active Server Pages 3.0. Chapter 6 is concerned with an explanation of objects. Some of you may have heard terms like 'object oriented programming', 'object models', and similar. In order, however, to understand what terms like this mean, we first need to look at the word found at the core of each of them - object.

This book teaches ASP and script-based programming from the ground up. It will answer the fundamental questions including - what exactly ASP is, how to get up and running with ASP, how it actually works, and how ASP can be used to produce dynamic, interactive web applications. As well as providing a thorough grounding in the fundamentals of ASP this book will also cover all of the new developments that come with Windows 2000 as well as showing you how ASP integrates with the latest versions of exciting new technologies such ADO, COM+ and XML. For further details about the book, and other books in our range, visit the Wrox Press Web Site.

  • Objects, Properties, Methods and Events
  • Programming with Objects
  • Altering the Properties of an Object
  • Calling Methods of an Object
  • What is the Active Server Pages Object Model?
  • Using the Object Model as a Road Map

Objects, Properties, Methods and Events

In this chapter, we will be looking at objects. Some of you may have heard terms like "object oriented programming", "object models", and similar. In order for us to understand what these terms mean, we first need to look at the word found at the core of each of them: object

In our study of objects, we will find that an object is a software representation of a real-world item, or object. Software objects feature properties (that describe the object), methods (that allow the object to do things for you), and events (code that is executed automatically when a certain situation - an event - occurs).

Once we have looked at what an object is, we'll then be able to look at how objects are useful to us in developing ASP applications. Developing web applications requires us to deal with both the client-side and server-side programming, and therefore we'll take a look at how objects can be used on both sides of the wire.

Before we get started, here is what we will cover in this chapter:

  • What is an object?
  • An introduction to properties, methods, and events
  • How can we change the characteristics of an object?
  • How do we know when the object tells us something?
  • What is an object model?
  • How do we use the object model in Active Server Pages?

We'll begin by taking a look at what an object is.

What is an Object?

In the real world, we already know what objects are. They're the things we look at, pick up, and use every day - things like our chairs, our telephones, and our computers. All these are solid, tangible entities.

However, if we want to describe a telephone to somebody in abstract terms, we can do this by talking about it in terms of its essential characteristics - what properties it has, what it can do, and how we can interact with it. All telephones have these characteristics, and we can use them to establish exactly how one telephone differs from the next.

So, for our telephone's physical properties, we could say that it has a microphone, a speaker, and a dialing pad. We could also say that it lets us do things, such as call someone and talk to them. Our telephone will also tell us when certain events are happening: for example, if a friend is trying to call you, your telephone will ring to let you know. This ringing will prompt you to take some action, like picking up the handset and talking to your friend. As an abstract object, our telephone has:

  • Certain properties that define and describe it
  • A set of things or methods that it lets us do
  • The ability to prompt action when events occur

We can use these three attributes to describe physical objects and abstract concepts. In a few minutes we will describe how these real-world ideas are replicated in software objects, but for now lets go a little deeper into our real-world telephone. By learning about what objects are, we can then look at how to use them in a way known as object-based programming. In the object-based way of programming, the application is broken down into a set of objects. In doing this, you can build the application in a two stage process. Firstly, you create the objects you will need in your application and then you set up the relationships and interactions between objects. Later in this chapter, we will see how the objects of Active Server Pages relate and interact with each other and allow us to build our applications.

Our Telephone in Detail


Here is our telephone. To look at this as an object, let's put down some information about it. We will be classifying the information into three categories:

  • Things that describe the telephone
  • Things that we can do with the phone
  • Things that the telephone tells us and that we can react to

Let's look at each of these aspects in turn:

Describe the telephone

The telephone is gray
The telephone is made of plastic
The handset weighs 6.5 ounces
The telephone has 12 keys
The telephone number is (714) 555-1523
The telephone is connected to the exchange

What can we do with it?


We can place an outgoing call
We can answer an incoming call
We can hang up the current call
We can enter our calling card number
We can disconnect it from the exchange

What can it tell us that we can react to?


Someone is trying to call us
The person we are calling is busy
Another person is calling while we are talking

How It Works

The three categories that we have created in the left-hand column can be applied to any object. In fact, the best way to describe an object is to break down its characteristics into these three categories, and put information about your object into these categories. Any information that you have about a particular object can be included in one of these categories.

If you have another telephone that features all these characteristics, except that its color is blue, then we can describe your telephone by changing that one part of the description above. Moreover, this technique works for any type of object, both real world and software.

Object Terms

So far, we have used verbose English terms to describe our three categories. In the world of objects, we need terms that concisely describe each of these three categories. These terms are properties, methods and events. In addition to these terms, we need to look at the term instance as it relates to objects. In this section, we'll look more carefully at what each of these means in abstract terms.

Instances and Classes

When we are talking about a unique object, we can use the term instance to say that we are talking about a particular telephone object - your telephone for example - that has a specific set of properties and values. When we want to talk about another telephone, we use a different instance of the telephone object. In this way, both you and I can have instances of the telephone object. For example, my telephone (my instance of a telephone object) is gray and comes with special answer-phone facilities, your telephone (your instance of a telephone object) may be red, blue, green etc. These instances represent completely different physical objects. However, since they are both instances of the same object description or template, they share the same types of characteristics such as methods, properties (although the values can be different), and events. When a specific instance of an object is created from the template for the object, the object is said to have been instantiated. What actually happens is that a copy is made of all of the properties and events from the object description, but the methods (frequently a big chunk of code) remain in the original place and this section of code is used by all of the different instantiations of that one object.

So we've mentioned object descriptions or templates, but it's time to give them their proper name in ASP;classes. We mentioned that each object can have different instances. For instance, my telephone is small and white and has 12 buttons. Your telephone will probably be different to that, but they're both recognizable as telephones and they both provide the same function. They both conform to a set of rules for what a telephone does - they connect to the local telephone line, they both have a numeric keypad and somewhere to speak into. A class in ASP is like a set of design rules that an object must conform to. It would be no good if my telephone didn't have a handset, or a numeric keypad, even if it did plug into the telephone socket on the wall. In a class there should be a minimum set of functions that your object must be able to perform.


When talking about those characteristics that describe an object, we are talking about the properties of the object. Each property of the object describes a particular aspect of the object. The property is actually described as a name/value pair. This means that for every named property, there is a single unique value that describes that property for this instance of the object. If we go back to our telephone example, we can create a table that lists each of the property names and the value of each property.

Property Name

Property Value






6.5 ounces




(714) 555-1523



We now have a set of properties that describe this instance. The properties of an object are used to represent a set of values associated with the object. A new instance of the object may have different property values, but it has the same property names.


Even with different property values, these two telephones are instances of the same object template. Since we know that all telephone objects have a 'Color' property, we can determine the color of each of the phones by examining its 'Color' property value. We can use properties in two ways. We can read from them or we can also write to them. So if we wanted, we could have changed the cover of our telephone to a different color, if we required.

Now that we have a way of describing the telephone object, let's take a look at what we can do with it.


Another characteristic of objects is that they can perform functions for us. For example the PlaceCall method would perform several functions for you. It will connect you to the local exchange, the exchange will route your call, and then when it reaches the destination, it will make the destination phone ring. These built-in actions occur whenever you pick up the handset and dial a number. This is a capability that has been built in to the machine.

However not all objects have functions like this. A chair object allows you to sit in it, so you could say that it is functioning to support your body. Objects that perform tasks that are more 'functional' are said to have methods. The tasks that an object can perform are called methods.

A method is defined as an action that an object can take. The code in a method is executed when the method is called. This calling is done by a command you write in the script of your ASP page. Once we have created an instance of an object, we can tell it to perform a certain task calling one of its methods.

Let's illustrate this using the telephone example. Our telephone object can carry out five methods. Each of these methods will cause the telephone object to perform an action. Here is a list of functions that the methods of the telephone object can perform:

Method Name



Place an outgoing call


Answer an incoming call


Hang up the current call


Enter or send our calling card number


Disconnect the phone from the exchange

These methods are used when we want our telephone object to perform a certain function; all we need to do is tell it to execute the corresponding method.

Methods are actually blocks of code that are written by the designer of the object (Microsoft, for example). The reason methods exist is because lots of programmers want to do the same job, so it is worth it for the gurus at Microsoft to write the code to do that job, test it, optimize it, and get it in great shape, then bundle it up in the object. We, as programmers, can then use that code pre-made. Instead of re-inventing the wheel we spend our time on the unique parts of our project.

Parameters of Methods

You may have noticed that some of the methods can be executed directly, while others look like they will need additional information. To contrast these two ideas, consider the following examples:

  • Suppose that our telephone receives an incoming call (in the next section, we'll see how we can tell that this is happening). All we need to do to answer the call is to use the 'Answer' method of our telephone object.

  • Suppose that we want to place a call. Simply calling the PlaceCall method isn't enough in this case: we need to supply more information (for example, the telephone number!) in order to complete the action.

Let's look more closely at the second of these examples. The telephone object has a TelephoneNumber property, and this is used to identify our telephone's own telephone number (i.e. the number that other people use to call us). So, the TelephoneNumber property of our phone isn't going to help us to make outgoing telephone calls.

So, how do we tell the phone which number we want to call? It's possible, I guess, for the telephone object to have another property, called OutgoingTelephoneNumber, that would identify the desired number; but that would be too cumbersome, because every time we wanted to make a call we would have to:

  • Set the OutgoingTelephoneNumber property value to the desired phone number

  • Execute the 'Call' method of the telephone object to place the call

As you know, telephones just don't work that way. It would be much more elegant (and intuitive) to have some way of passing the outgoing phone number to the 'Call' method, so that we can place an outgoing call in a single step. This is done by passing a parameter to the 'Call' method. With this in place, we can place an outgoing call by simply executing the 'Call' method and telling it which number we want to call, like this:

  • Execute the 'Call' method of the telephone object, passing the outgoing telephone number as a parameter. Parameters here are just the same as the arguments(parameters) we passed to functions and subroutines in the last chapter.

If we look again at the methods of the telephone object, we can identify those methods that require parameters, and what the values of those parameters mean to the object:

Method Name



Outgoing telephone number


No Parameters


No Parameters


Calling card number, PIN


No Parameters

You can see that a method can have none, one, or more than one parameter. The SendCardNumber method actually requires two parameters. You are required to pass in both the calling card number and the personal identification number (PIN) in order for the method to execute properly. Information passed as parameters of the method for execution by the method, will only be executed if all parameters have been supplied.

Return Values

In addition to passing parameters to a method, the method can also return information to us. The value returned by a method is (rather conveniently) called a return value. If a method has a return value, then it will pass information back to us. This information could have a number of purposes. For example, the return value might be an indication of whether or not the method completed successfully. Alternatively, the method could also pass back the results of some processing that it did for us. It can even return another object as a result.

As the user of an object, we can decide whether we want to do anything with the return value. If the information is pertinent to what we are doing, then we can capture the return value and do something with it later. If we do not care what the return value is, we can just ignore it and continue with our work.

Just as the methods of the telephone object can have parameters, we can identify those methods that pass return values (and these can be passed as parameters to other methods), and what those values mean.

Method Name

Return Value


True (if call completed successfully)
False (if call failed)


No Return Value


True (if telephone was hung up successfully)
False (if not)


True (if card was accepted)
False (if card was not accepted)


No Return Value


We have now looked at two of the three characteristics of an object. The properties and methods of an object are ways that the user of the object can communicate with the object. Now, what if the object needs to communicate with the program that created it?

As an example, consider what happens when our telephone receives an incoming call. The fact is that it needs some way of telling us to answer the call. How will the telephone communicate this information to us?

Again, it's possible for the telephone object to have a property (called IncomingCall, perhaps) that was set to 'True' whenever an incoming call was present. However, there are two disadvantages to this. First, it would require the user of the telephone object to check this property on a regular basis. Second, the user would require a great deal of knowledge of the inner workings of the object, which isn't ideal.

What is needed is a way for the object to tell the user that something has happened. The mechanism for this is called an event. An object generates an event whenever something of interest happens. In our telephone example, when the telephone receives an incoming call it tells us so in the form of an event - we'll call it the IncomingCall event. (On most telephones, this particular event takes the form of the telephone ringing.)

The telephone object would generate an IncomingCall event every time an incoming call is received. In a physical phone, the ringing sound is the phone notifying you of the IncomingCall event. When the user receives this event, it can execute the 'Answer' method (pick up the handset), and begin the call. This frees the user from having to check regularly for incoming calls: the event is designed to notify the user just at the appropriate moment.

Just like methods, events can have parameters. These parameters can hold specific information about the event. For example, if our telephone supports CallerID - a feature that reveals the identity of the incoming caller - then the IncomingCall event could include a parameter that contains the telephone number of the incoming caller.

Here is a list of the events that our telephone object will generate, along with their associated parameters:

Event Name



Incoming CallerID information


No Parameters

There are a couple of useful pieces of terminology that are often used in this context. When an object generates an event, the object can be said to fire the event. When the object has fired the event, we say that the user must handle the event.

Synchronous vs Asynchronous

One of the advantages of working with objects and events is that it awakens us to the concept of asynchronous programming. First off, let's look at the definitions of synchronous and asynchronous.

These terms refer to how two separate actions are related to each other. If the first action must be completed before the second one begins, then these two actions are said to be synchronous. If the second action can begin at any time, no matter what the status of the first action, then these two actions are said to be asynchronous.

We've already discussed what it would be like if we our objects didn't support events. For example, to detect an incoming call, you would need to constantly check the value of some property to see whether an incoming call was waiting. While you're performing these frequent, regular checks, you would be unable to perform other tasks dependent on the outcome of that task. This is an example of synchronous activity. For example in the real world you might be waiting for a telephone call from a friend to let you know what time you should meet them. You can't go out until you've arranged a specific time. It's the same in programming. Your program could be waiting on a WaitForAnIncomingCall method in a While ... Wend loop, and it could be stuck there until the call was detected, refusing to return control to the main body of your program.

With events, we can have asynchronous activity. By having an event handler that is called when the object fires the 'IncomingCall' event, we can perform other tasks (for example, making an outgoing phone call) without having to devote any effort to monitoring the incoming call status. Our event handler code will be dormant until such a time as it detects the 'IncomingCall' event, and then sets about dealing with the incoming call.

This is not to say that all synchronous is bad and all asynchronous is good. You will see many instances in the real world where it makes sense to use a synchronous activity to perform a certain type of processing. Likewise, we will also see instances where an asynchronous activity is not an optimal way of dealing with an event.


One great thing about objects is that you don't have to understand what's going on underneath the shell, to know how to operate them. With our telephone we don't need to know how our voice is projected from the phone, down the wires to the nearest exchange, and how from there it gets to our intended destination. This is all hidden from us. It's the same in ASP - you don't need to know how the object was programmed, for example, in C++ or VB (objects can be created in many languages), to be able to interact with it. The concept of a user of an object not being concerned with the inner workings of the object, is known as encapsulation. For example, when you use a telephone to answer an incoming call, all you need to do is pick up the handset. You don't need to know how the transistors are connected to each other inside the telephone. This is the equivalent of executing the Answer method. You do not need to know what's going on underneath - that's all encapsulated within the Answer method. This is an example of encapsulation.

... One advantage of encapsulating the workings of an object within a method is that the implementation of the method can be changed without having to adjust the client. For example, suppose the phone company decides to change the way that an incoming call is answered. Without encapsulation, all of the users of the telephone object would have to be adjusted to support this new way of answering the phone. Instead, by encapsulating these new steps within the Answer method, the actions of the client never need to be changed: with either system, all the client needs to do is execute the 'Answer' method. Not only does encapsulation make the telephone user's life easier; it allows the developer of the telephone object to change the implementation at any time.

Moving On to Programming

Now that we have a basic understanding of what an object is, we can move on to looking at how programming concepts have changed from traditional methods by using objects. When working with objects in software development, we will create objects that have properties, events and methods. We can use these three attributes to describe physical objects and abstract concepts. Either way, the programmatic object will allow us to interact with it through its properties, events and methods.

Read More Show Less

Table of Contents

Chapter 1: Getting Started With AS
Chapter 2: Web Server Fundamentals
Chapter 3: Basic ASP Techniques
Chapter 4: Storing Data in ASP
Chapter 5: ASP Control Constructs
Chapter 6: Objects, Properties, Methods and Events
Chapter 7: The ASP Request and Response Objects
Chapter 8: ASP Applications and Sessions
Chapter 9: Scripting Techniques
Chapter 10: The Scripting Objects
Chapter 11: Using External Components with ASP
Chapter 12: Data Stores and ASP
Chapter 13: Using a Recordset
Chapter 14: Advanced Data Handling Techniques
Chapter 15: Building Web Applications with ASP
Chapter 16: Introducing Component Services
Chapter 17: Building Script Components for ASP
Chapter 18: Introduction to XML
Chapter 19: Working with XML Data in ASP
Read More Show Less

Customer Reviews

Average Rating 4.5
( 7 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Terms of Use.
  • - Barnes & reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 7 Customer Reviews
  • Anonymous

    Posted October 10, 2001

    Excellent book - easy to understand!

    I have thoroughly enjoyed the way the author's of this book do their teaching. They present the concepts of ASP in a meaningful fashion. They also have organized the book to hold your interest. I would HIGHLY recommend this book if you have heard of ASP and really want to know what you can do with it. I have some Visual Basic programming experience which is helpful since ASP mainly used VB Script. But do not be afraid if you have never programmed before. The book will teach you well! I have tried a couple other books on ASP and found them complicated and poorly written.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted September 5, 2001

    Couldn't ask for a better book

    I'm only on chapter eight and this book is a phenomenon. I've never read a book like this before. The authors took their time to make sure the readers will fully understand each and every concept. This book is not intimidating at all. I appreciate the publisher and the authors for doing there best and being concerned about the readers. I highly recommend this book to the beginners interested in learning about Active Server Pages.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted June 13, 2001

    Clear and gets the point across well, but TYPOS!!

    This book has a great way of explaning how ASP works and how the code works. After every Try it out section is breaks down every line of code to explain what is going on and why it is done. I've read many programming books and few give this much detail for even non-programmers to thoroughly understand. It thin the book is great---even with the typos which aren't that big of a deal if you go the thier website and print out the errata. Just about every typo has been documented with a fix. I wwas able to progress through the book just fine. They explained things so well I was able to even catch and fix the typos before looking at the errata sheet!! Just goes to show how well things are explained here. I recommend this book for any non-programmer who wants a non-condescending (the Dummy series) introduction to ASP.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted February 27, 2001

    Great Book

    Great book to learn ASP with great examples. Experienced programmers may skip some basic programming theory. Examples are very good and also the support given by WROX press is excellent and you can download the samples from their web site.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted December 23, 2000

    Recommended for Beginners

    The book is excellent for beginners. After reading the book, I was able to grasp the workings of ASP and now moving on to ASP+.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted March 6, 2000

    Typographical Errors Abound!

    This book covers the topic completely and in a well-organized manner. The writing style is enjoyable. It is unfortunate that the book is marred by numerous typographical, grammatical and syntactical errors, some of which affect the code samples causing them to either not behave as they were intended to or to fail completely. Book buyers should expect a $40 book to exhibit evidence of careful editing - this book does not.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted February 11, 2000

    Improved documentation and code samples

    This publication is a must for any ASP developer. The sections on CDONTS and the Command objects are excellent for developing a SQL Server application with stored procedures. There is more in-depth coverage of the topics from the 2.0 book. More sample code is provided. The new subjects covered (i.e. COM, CDO, and XML) will prove their worth.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing all of 7 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)