Object Oriented ASP: Using Classes in Classic ASP

by Richard Quinn

Do you know how much of a nightmare some ASP pages can be? Do you know how disastrous it is to intermingle HTML with program code? Yes, you do, I know you hate it too! Been there, seen that, you've probably got some cool tricks to reduce the clutter in your own work. Perhaps you use functions extensively, putting away code from out of your HTML and into an include file? Well here's an article showing you how you can take this principle (called information hiding) to a new dimension!

The bookstore example.

Lets take a hypothetical web site, its a library's site detailing information about books! Books are a good example, really, because everyone can see how online bookstores work from a customer perspective.

Books have certain attributes, here I'll list some:

  1. ISBN Number
  2. Author(s)
  3. Title
  4. Subtitle
  5. Number of Pages
  6. Binding Type
  7. Publisher's Name
  8. Published Year

Of course this list is not exhaustive, try here for an exhaustive list of attributes you can collect about books! For our purposes it's enough. If you don't want to store your book data as XML, a relational database is a good idea.

Before looking at how you want to store this information, it's worthwhile modeling the objects first. You can see that I've identified two separate objects, books and authors. Publishers or binding types are certainly other candidates, but they would complicate the example a little too much.

Book Class Diagram
Figure 1: Book Class Diagram

As you can see, both the book and the author classes have a common set of operations: LoadFromID, Store and Delete. Real OO purists would start decomposing the classes here and make them share, or inherit, these operations from another class. But VBScript can't do this, so I'll leave this explanation for another day :) Another necessary feature is the attribute ID. Imagine you have thousands of books and tens of thousands of authors. A convenient way to identify individual entities is by using some form of self-generating ID, which I've modeled here.

Here is a diagram which shows some of the data entities you may consider when modeling your database:

Book Entity Relation Diagram
Figure 2: Book Entity Relation Diagram

The main point to notice is that the data is partially normalized, author data is stored separately from book data. An association table is used to create relationships between books and authors, whereby an author may have written several books, and a book may have been written by several authors. This principle can also be applied to the binding type column or to the publishers name column, in practice you will want to normalize this data too.

You may or may not like the way I name the tables and the columns, but that's your problem :) This scheme has been very useful for me in the past, and I'm sticking with it. Tables are named in the singular, since they represent an entity from the real world. Columns have a prefix denoting the data type of the field: lng: Long Integers, str Strings, dtm: DateTime. The column prefixes are only intended to be useful to humans who can immediately see what data type goes in the field and can make educated guesses about how to use or format the data there. The suffix: ID is reserved for fields which form a primary or foreign key. For a more detailed discussion of primary and foreign keys, indexes and IDENTITY fields, you should see the documentation which comes with your make of database.

An interesting side note is that these diagrams are as equally useful to librarians as they are to programmers or to database administrators. True, each group may get something additional from the diagram, but the terms used and the relationships shown are based on real world scenarios and need little interpretation. Avoid cryptic names and unclear associations, they are more trouble in the long run.

The application.

OK, now we have fairly detailed information about the application we want to build, we've even shown it to the client and had them sign that they agree that it says what they want them to say! So lets get down to building the application, making the Database, the HTML and ASP pages and testing it all! Right? Wrong!

The first thing we should be doing is building the classes which represent the two objects we've identified. This well help is to clarify what we're doing, any changes we come up when building the objects can be easily accommodated, since neither the database nor the ASP pages yet exist, and therefore do not need to be re engineered.
I'm assuming you've heard of VBScript classes, and know that they are formed within this code construct:

Class cClassName
'some code....
End Class

OK, here comes an example attribute of the book class, its ISBN number:

'Private, class member variable
Private m_ISBN
'Read the current ISBN value
Public Property Get ISBN()
      ISBN = m_ISBN
End Property

'store a new ISBN value
Public Property Let ISBN(p_Data)
      m_ISBN = p_Data
End Property

This was the ISBN attribute. The actual value of the ISBN is stored in a private variable, called m_ISBN. Here I also use prefixes to identify the variable as a member of the class. Doing this allows us to check that values written to or read from the class are never badly formatted or just plain wrong. They are doorways to the hidden insides of the class, we can check what's coming in and going out. Here is the partial book class containing all of its attributes.

Now I can show you an example of how the class could be used. This is old style, questionably useful ASP code mixed in with the HTML:


Of course, you needed reams and reams of supporting code to build the connection, get the data out of the DB and loop through the records, outputting the values directly into the HTML. Well here is how we create an object from our book class:

<% Set MyBook = new cBook %>....

You can see an improvement in the code already, it is self describing. You can see immediately that the book's title is being placed in within the table cell, no more remembering what is in which field of your recordset. Also, of course, if the book doesn't yet have a title, you might need to do something like this in old-style ASP:

   strTitle = MyRecordest.Fields(1).Value
   if strTitle = "" then strTitle = "no title yet"
   response.write strTitle

In an OO approach, you can put this behaviour inside the class, specifically, in the property attribute accessor method:

Public Property Get Title()
    If m_Title = "" then
         Title = "not title yet"
         Title = m_Title
    End If
End Property

This cleanly separates the business rules ("if there is no title display a message saying so") from the presentation of your information. Your improved ASP code:


...will conform to the business requirements without messing up your presentation. If the business rules change, and they often do, you can make the modification in one location within your class, and not hunt through every HTML page for every instance of where you have printed the title. Life is starting to get much easier, but there is more!

You run into real difficulties when your DB code for reading, updating and deleting the data is repeated all through your web site, whereever you needed to display it. If you change the database you may need to modify lots of web pages to reflect the changed database structure. Wouldn't it be easier if the DB code were stored directly in the object? You would only need to write it once, store it in your class file and reuse it wherever you use those objects in your web site? In the object diagram above, the place to store this code is in the operations LoadFromID, Store and Delete. I'll show you first how this functionality can be easily used in your web pages, and then how it is implemented in the class file.

Creating and loading a book object in ASP, then displaying the book's information within HTML:

'Create an empty book object,
'Load the object's data based on an ID you get from the request,
'Display the books's information.
Set MyBook = new cBook

<tr><TD>Title: <%=MyBook.Title%></td></tr>
<tr><TD>SubTitle: <%=MyBook.SubTitle%></td></tr>
<tr><TD>Publisher: <%=MyBook.PublishersName%></td></tr>
<tr><TD>Year: <%=MyBook.PublishedYear%></td></tr>
<tr><TD>Format: <%=MyBook.BindingType%></td></tr>
<tr><TD>ISBN: <%=MyBook.ISBN%></td></tr>

No database code, no worries, everything is hidden away in the implementation of the LoadFromID operation.
I have created a new database for this example using Microsoft Access, "vboo_pubs", based on the example pubs database in SQL Server. It has 3 tables which interest us, book, author and authortobook, which happily directly correspond to the three tables in the entity relationship diagram above. This is how I would implement the LoadFromID operation, using the vboo_pubs sample database:

Public Function LoadFromId(p_Id)
Dim rs, conn, strSQL
Set Rs = Server.CreateObject("ADODB.Recordset")
Set conn = Server.CreateObject("ADODB.Connection")

conn.open "vboo_pubs"

strSQL = " SELECT T.title_id, T.title, T.type, "
strSQL = strSQL & " T.pub_id, P.pub_name, T.pubdate, T.notes "
strSQL = strSQL & " FROM titles T INNER JOIN publishers P ON T.pub_id = P.pub_id "
strSQL = strSQL & " WHERE (T.title_id = '" & p_Id & "') "

rs.open strSql, conn, 1,3

if rs.recordcount =1 then
Me.ID = rs.fields("title_id").Value
Me.Title = rs.fields("title").Value
Me.PublishersName = rs.fields("pub_name").Value
Me.PublishedYear = rs.fields("pubdate").Value
Me.BindingType = "" ' No data available!
Me.SubTitle = rs.fields("notes").Value
Me.ISBN = rs.fields("pub_ID").Value
LoadFromId = Me.ID
mvarSaveOnTerminate = true
err.raise 1, "Item with ID " & p_ID & " was not found"
End if

Set rs = nothing
Set conn = Nothing
End Function

To get this example working you need to have an ODBC data source set up named "pubs", which the object uses to connect to the database. You may have noticed that there is no error handling in this code, this is purposely bare - bones so that you can deal with errors your self. The code actually raises an error if it can't find the record being searched for, this is for your web pages to deal with appropriately. Sometimes not being able to fin a record is unimportant, other times it is critical. The class does not know in which circumstance it is being used, and makes no assumptions about how to deal with errors.

The LoadFromID operation is essential if you want to get the data from your database into the object, and you have an ID. But what if you don't have an ID, but lets say the ISBN? Well, you would create a LoadFromISBN function. Since the two functions are different only in the SQL statement they produce, it would make sense to start refactoring here, and put the database access code somewhere separate from the SQL generation code. Here is the refactored LoadFromID along with the LoadFromISBN operation.

'Loads this object's values by loading a record based on the given ID
Public Function LoadFromId(p_Id)
dim strSQL, MyID
MyID = clng(p_Id)
strSQL = "SELECT lngBookID, strTitle, strSubTitle, strISBN, strBindingType, "
strSQL = strSQL & " strPublishersName, strPublishedYear, strPageCount FROM Book "
strSQL = strSQL & " WHERE (lngBookID = " & MyID & ") "
LoadFromId = LoadData (strSQL)
End Function

'Loads this object's values by loading a record based on the given ISBN
Public Function LoadFromISBN(p_Id)
dim strSQL
strSQL = "SELECT lngBookID, strTitle, strSubTitle, strISBN, strBindingType, "
strSQL = strSQL & " strPublishersName, strPublishedYear, strPageCount FROM Book "
strSQL = strSQL & " WHERE (strISBN = '" & SingleQuotes(p_Id) & "') "
LoadFromISBN = LoadData (strSQL)
End Function

Load Functions

The LoadData function is quite complicated. Since this is not a tutorial about database connections, I have left it to be shown in the complete class listing. Both of these functions return the ID of the book which has been loaded.

The Store and Delete operations do exactly what you expect. Suppose you want to create a new record in the database, how would you do this in an OO way in ASP? This is very easy to do, the hard part is coding the SQL statement, so I'll do that for you. The interesting thing to note here, is that the Store operation is called not just when creating a new database record, but also when saving changes which may have been made to an existing record. You can now do inserts and updates from a single ASP page entitled "Create / Update Book Information":

  1. If the page is called with a book ID, load the book object, otherwise create an empty book object
  2. Show the editing form, and fill it with the values from your book object. The fields are either empty or they show the existing data
  3. When the user submits the form, again see if you have received an existing ID. If yes, load that book object, otherwise create an empty book object
  4. Assign the form values to the object's properties
  5. Call store on your book object. It runs an update or an insert operation automatically

Here is the Store operation:

Public Function Store()
Dim strSQL
'If the book has an existing (Autogenerated!) ID, then run an insert
if Me.ID < 1 then
Dim ThisRecordID, arr1, arr2
arr1 = Array("strTitle", "strSubTitle", "strISBN", "strBindingType", "strPublishersName", "strPublishedYear", "strPageCount")
arr2 = Array(Me.Title, Me.SubTitle, Me.ISBN, Me.BindingType, Me.PublishersName, Me.PublishedYear, Me.PageCount)
Me.ID = InsertRecord("Book", "lngBookID", arr1, arr2)
'Otherwise run an update
strSQL = strSQL & " UPDATE Book SET "
strSQL = strSQL & " strTitle = '" & Me.Title & "',"
strSQL = strSQL & " strSubTitle = '" & Me.SubTitle & "',"
strSQL = strSQL & " strISBN = '" & Me.ISBN & "',"
strSQL = strSQL & " strBindingType = '" & Me.BindingType & "',"
strSQL = strSQL & " strPublishersName = '" & Me.PublishersName & "',"
strSQL = strSQL & " strPublishedYear = '" & Me.PublishedYear & "',"
strSQL = strSQL & " strPageCount = '" & Me.PageCount & "'"
strSQL = strSQL & " where lngBookID = " & Me.ID
End if
Store = Me.ID
End Function

And here is the delete:

Public Function Delete
strSQL = "DELETE * FROM Book WHERE lngBookID = " & Me.ID
End Function

So we've done the hard work, and made the class. Hard work? Yes and no. It will initially seem like a lot of work, defining the member variables, writing attributes to access them, then writing the DB code and testing it all (hopefully using a unit testing framework like ASPUnit). And all this without any HTML, no web pages, nothing. But that's the beauty! Now you can give a HTML Dude a list of the Objects attributes, and he can make the HTML pages, whilst you go on to make and test the next class file! And of course, because each class file looks almost exactly the same as the previous one, you can automate the production of them! My favourite is to define an XML structure containing all of the attributes of the class, and then write an XSL to transform the XML into a valid VBScript class. Making this kind of system shouldn't take more than a day, writing the XML files for your application's classes no longer than a further day, leaving you weeks and weeks to make funky HTML :)

So here is some of that funky HTML. Earlier, I showed a simple page used to display a book object using HTML. Here is the page which will allow us to edit an existing book object or to create a new one:

<!-- #INCLUDE virtual="/zzTest/cBook.asp" -->
<!-- #INCLUDE virtual="/zzTest/cAuthor.asp" -->
<!-- #INCLUDE virtual="/zzTest/cLibrary.asp" -->
<!-- #INCLUDE virtual="/zzTest/i_helper.asp" -->

dim MyBook
Set MyBook = new cBook

if request("bookid")<>"" then
end if

if request("cmd")<>"" then
Mybook.ISBN = Request.Form("isbn")
Mybook.Title = Request.Form("Title")
Mybook.SubTitle = Request.Form("SubTitle")
Mybook.ISBN = Request.Form("isbn")
Mybook.BindingType = Request.Form("BindingType")
Mybook.PublishersName = Request.Form("PublishersName")
Mybook.PublishedYear = Request.Form("PublishedYear")
Mybook.PageCount = Request.Form("PageCount")
end if


<form name="form1" method="post" action="edit_book.asp">
<table border="1" cellspacing="0" cellpadding="0">
<td width="134">Book ID</td>
<td width="12"><input type="hidden" name="cmd" value="edit"></td>
<td width="598"><input type="hidden" name="bookid" value="<%=Mybook.ID%>"><%=Mybook.ID%></td>
<td><input size="50" name="isbn" value="<%=htmlencode(Mybook.ISBN)%>"></td>
<td><input size="150" name="Title" value="<%=htmlencode(Mybook.Title)%>"></td>
<td><input size="150" name="SubTitle" value="<%=htmlencode(Mybook.SubTitle)%>"></td>
<td>Binding Type</td>
<td><input size="50" name="BindingType" value="<%=htmlencode(Mybook.BindingType)%>"></td>
<td><input size="50" name="PublishersName" value="<%=htmlencode(Mybook.PublishersName)%>"></td>
<td>Published Year</td>
<td><input size="50" name="PublishedYear" value="<%=(Mybook.PublishedYear)%>"></td>
<td>´Number of pages</td>
<td><input size="50" name="PageCount" value="<%=htmlencode(Mybook.PageCount)%>"></td>
<td>&nbsp; </td>
<td><input type="reset" name="Submit2" value="Reset"> <input type="submit" name="Submit" value="Submit"></td>

<a href="./default.asp">List</a>

You can download the whole project here.

Navigating from Authors to Books.

As we saw above, instantiating a book object and loading its attributes based on an ID number is very simple. But how do we navigate from our book object to the authors who wrote the book? Well, if we look at the class diagram above, the "0..*" text on the line between books and authors says that a book refers to zero or more authors. Also, an author has a relationship with zero or more books. Strictly speaking, we don't really want to be managing the data of authors who haven't written anything in our library, but the situation occurs often in real life, when for example the author's first book has not yet been published.

The book object has a property, called "Authors". Using object notation we can reference the first author in the collection of the books authors like this: Mybook.Authors.Items(1).LastName

This is how the property is built:

Public Property Get Authors()
if not isobject(m_Authors) then
set Library = New cLibrary
Call Library.GetAuthorsByBookID(Me.ID)
set m_Authors = Library.Authors
Set Library = nothing
end if
Set Authors = m_Authors
End Property

This uses the "Lazy Load" design pattern. The book object does not contain any authors until you actually request author information. The property checks to see if the m_Authors collection has been initialised, if not it initialises a new Authors object. The Authors collection is provided by the library. The library does not have a persistent representation in the database, it has no attributes which we want to display just yet. It does have a large number of operations, representing the functions that a library performs.

In our case, the operation "Library.GetAuthorsByBookID(Me.ID)" asks the library to return all of the authors associated with a particular book as a collection. The library uses some simple SQL to retrieve the requested records from the database. For each record returned, the library creates an author object and initialises the author's attributes. The author object is then added to the collection. The library informs the book about the number of authors created, and stores the collection in its "Authors" property. The book requests the Authors from the library object then stores the author collection internally for speedy future access: "Set m_Authors=Library.Authors()".

Navigating from Authors works in exactly the same way, the Author object has a property called "Books" which represents all the books written by the author. Requesting "Author.Books" returns a collection object, internally the library services the request by retrieving the data from the database, creating book objects and returning them as a collection.

It may be becoming clearer now, that writing ASP classes to model the real world is a lot of effort up-front. This effort can be justified:

  • The classes produced are independent of HTML.
  • The classes can be thoroughly tested and verified before being used by your HTML people.
  • The classes can be coded parallel to screen design or HTML prototyping activities, allowing previously sequential project activities to be performed in parallel.
  • The SQL is hidden away where the DBA / Developer can find it, the designer never sees it.
  • The code produced is reusable. In the real world this small example may take up to a whole day to code and test, but can then be used by several people to actually build a real world application.
  • Your users get a higher quality application (faster, more reliable, more easily modified, errors are localized more quickly, easily maintained, fewer errors).


This tutorial has given you an insight into how ASP classes are built. Attributes and operations have been discussed. Navigation between classes has been explored as one of the fundamental abilities of Object-Based systems. The classes presented here use an "Active Record" persistence pattern, each object represents one record in an associated table in the database. The Library object was introduced as a non persistent class which services the request of other objects.

This tutorial presents a domain model. That is, real world objects and their associations are called the problem domain, our database, classes and web pages are part of the solution domain. Our objects closely resembled real world objects. There are other ways of architecting applications than by using a domain model, but this way really does leverage the power of object based systems.

The book and Author classes are responsible for instantiating their own data, but as you may have seen, the library class also instantiates books and authors en masse when creating collections. This is a conceptually "dirty" way of doing things. It would be much nicer if the code for assigning field values to object attributes were only in one place, the risk of bugs would be much reduced. Unfortunately, the need for performance means that an entire table of records must be initialised in a single step.

On the performance side, things could be improved dramatically. Each book is instantiated separately from each author. A minimum of two database calls are necessary to first retrieve the book data and then retrieve the authors data. Folding this into a single call with responsibility for instantiating both book and author data would bring noticeable performance and scalability advantages.

There is a questionable resolution of the problem originally presented: separation of code and HTML. In order to output the object's attributes, a fair amount of scripting is still necessary. True, we have moved away from scripting the database and the HTML to scripting objects and HTML, but a cleaner separation could be achieved if each object had a "Render(OutputFormat)" operation which could make a visual representation for display in the desired output format, for example HTML.

For a fuller understanding of how the navigation between books and authors is implemented, a good look at the accompanying code is essential. There are some tricks and goodies in there which will surprise and delight even the most advanced of ASP authors :)

You can download the whole project below.

About the Author

From ASP101

Articles originally posted on ASP101.com



  • GHD glattejern er helt unike og det er ogsÃ¥ derfor de sælger sÃ¥ godt

    Posted by wanzixiao on 05/30/2013 08:23am

    [url=http://www.glattejernghd.webstarts.com/]Glattejern ghd[/url] Hurtigt snart efter detoksificering låse, følgende gør nogen forskel i øjeblikket at blive i stand til at eventuelt kunne være blevet tabt hår. De er rent faktisk nødvendigt at undgå vilde hår skade som følge af varme niveau priser pres på grund af type og konstruktion regnfulde og desuden fugtigt krøllede hår. Umiddelbart efter erhvervelse af for at blive udtørret låse, skal du helt oprydning denne bestemte slags, så du kan fjerne troubles sammen med hår. Sørg som head of hår kan være helt helt moderne sammenholdt med gået tabt ved udnytter plus desuden drage fordel med de sande ghd fladjern tekniske personale, overbevisninger protectant. At kunne erhverve til at blive en specifik forsvarende flick, så du kan reducere varme niveau værdier skade bil Frisure plus stil tilgang. Varm temperatur protectant kan også dygtig bo klart af tilfældige krøllede hår anvender op. [url=http://www.ghdglattejern.tripod.com/]ghd danmark[/url] Masser af enkeltpersoner butik på internettet inden for ord, der involverer lethed og komfort som et alternativ til køber bistand. Kunde plan online giver forbedret alligevel den faktiske individuelle del af off-line indtjening fortsætter med at være mangel på. En række art vedrørende organisation bliver salon eller blot en fase spa bygger op med bestemt person lidenskabelig forbindelse. Hver eneste solo valg forbundet med disse former er forbundet med dejlige stylers kan godt forekomme at arbejde med smukke person, temps beskyttelse quiltet håndtaske som lysarmaturer farve sammen sammen med dinGhd Fladjern er du nødt til at få ram på den samme tid til at få set næsten enhver dårlig situation, som i turn repræsenterer du eventuelt kunne gemme disse mennesker specielt præcis, hvor du vælger at bevæge sig fremad. Mens absolut alle fuldt ud at forstå god hår dage er virkelig identificeret sammenlignes for at hjælpe en fantastisk virksomhed, der vil ofte leverer din ideelle køber bistand, som vil betyder du vil være i stand til regelmæssigt at generere komme i kontakt med med den slags forbundet med. rød-farvet Lust Gode hår dage vil uden tvivl øge taget i betragtning tilsluttet låse system. [url=http://www.ghdfladjerntilbud.webgarden.com/]Ghd fladjern tilbud[/url] Men det er vigtigt at notere sig at varmepladerne inden i dit ghd glattejern er samme størrelse som de keramiske plader udvendigt. Så jo større glattejern, jo større varmeplader. Dette har man gjort for at sikre sig at alle ghd glattejern har den helt rigtige og helt jævne fordeling af varmen. På den måde sikre ghd sig nemlig at deres glattejern glatter dit hår ordentligt første gang og glatter det hår du arbejder med helt lige og jævnt.

  • The actual reason why many people are dead wrong concerning shoes and also why you have to look at this ebook.

    Posted by BobHotgloff on 05/27/2013 01:15am

    Basic principles of the sneakers that one could cash in on starting up today. [url=http://www.shoesjp.biz/new-balance【ニューバランス】-c-670.html]ニューバランス[/url] The reason every little thing you have read about sneakers is actually drastically wrong and what you need to understand. [url=http://www.shoesjp.biz/nike【ナイキ】-c-634.html]ナイキ ランニングシューズ[/url] Quick review explains some of the intricacies for shoes combined with those things that you must do right now. [url=http://www.kutujp.biz/]アディダス[/url] Advanced shoes E-book Unveil Method To Rule The shoes Market [url=http://www.kutujp.biz/アディダス-adidas-c-4.html]アディダス シューズ[/url] Reasons all kinds of things that you've found out about sneakers is undoubtedly drastically wrong and what you need to realize. [url=http://www.kutujp.biz/アシックス-asics-c-3.html]アシックス[/url] Ideal key for shoes you can learn about this afternoon. [url=http://www.kutujp.biz/ナイキ-nike-c-13.html]nike[/url] Creative write-up unearths the suggestions on the shoes and consequently reasons why you should take action as we speak. [url=http://www.kutujapan.org/]ベルーナ[/url] Innovative shoes E-book Explains Strategy To Dominate The shoes Scene [url=http://www.kutujapan.org/adidas-アディダス-c-74.html]adidas originals[/url] Creative shoes Publication Reveal Methods To Rule The sneakers Scene [url=http://www.kutujapan.org/new-balance-ニューバランス-c-13.html]newbalance[/url] Whatever the industry experts normally are not revealing surrounding shoes and also how it is affecting you actually. [url=http://www.kutujapan.org/nike-ナイキ-c-78.html]ナイキ ランニングシューズ[/url] The actual reason why most are absolute wrong around sneakers and also the reasons you ought to ought to see this analysis.

  • Lightweight perceptive – Nike Let off TR Attack in spring 2013 3 series

    Posted by Tufffruntee on 04/21/2013 11:56am

    Nike Free TR Suited 3 unmistakable features is to exploit the trendy design: Nike Free 5 soles improved bending Striation; stylish tractor pattern making training more focused when; lighter preponderance, the permeability is stronger, and more smart shoe designs not only order shoes [url=http://northernroofing.co.uk/roofins.cfm]nike free run uk[/url] more pleasant wearing, barefoot training caress, but also more fashionable appearance. Nike On the house TR Then 3 provides first-class lateral reliability, you can take the legs in the lap boost during training. Acrid vamp upper breathable grate, lower sparkle's solitary map can be [url=http://northernroofing.co.uk/roofins.cfm]nike free run[/url] seen from stem to stern it. Lightweight, difficult, thin soap up matter occupied at hand entirely only one seams, more obedient, forward is stronger. Lack more support, part of a training utilize, froth make inaccessible in more parts of the neediness after flexibility, foam loose. Say stand-in talk moisture wicking counterfeit materials, unshiny on your feet, refrain from maintain feet tiring and comfortable. Phylite [url=http://fossilsdirect.co.uk/glossarey.cfm]nike huarache free[/url] midsole offers lightweight shock level, outstanding durability and even outsole can do to greatly adjust the all-embracing avoirdupois of the shoe. Qianzhang pods on the outsole and heel-shaped Green rubber enhances the shoe multi-directional purchase on odd surfaces.

  • :)

    Posted by Mo on 12/03/2012 09:09am

    Absolutely fantastic! Thanks for the effort. Keep up the good work. :)

  • a way deploy cut price catalogues

    Posted by BeisseDix on 11/10/2012 03:02pm

    prostate scenario through several drive while they are urinating Belstaff Outlet-Belstaff Sale-http://www.belstaff-outlet.info

  • Downloads missing

    Posted by RP on 05/02/2012 02:45pm

    Unfortunately the example files/source samples are no longer available...

Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

Most Popular Programming Stories

More for Developers

RSS Feeds

Thanks for your registration, follow us on our social networks to keep up-to-date