Compared to its more recent version, Access 2003 is a jungle. For all of your internet database displaying needs, Jayaram Krishnaswamy is here:

“In a related article on importing into MS Access 2003 from an external source using its built-in support for such an activity, we fell short of a complete success unless some styling/schema information could be supplied. This tutorial looks at the reverse process, namely exporting data from MS Access into XML format.This article is about exporting XML data from MS Access 2003. XML is the lingua franca of the Internet and is used extensively in how we communicate. XML is ubiquitous and will become more so with time. The extensibility, the essentially text-based format, and the ability to carry the data in its body make it unique, and extremely useful in how information is disseminated.

MS Access has gone through many revisions, and over time it has added support for importing and exporting its data into HTML as well as XML. One look at the source view of the Data Access Pages, a new object to display data on the intranet which appeared in version 2000 and above, reveals how deeply these different formats have penetrated the product. According to the product document, MS Access 2003 fully supports importing and exporting XML. In addition to the built-in support explored in this article, and the previous one dealing with importing, one could also use scripting support to explore this functionality in MS Access 2003. But this is not considered in this tutorial.”

Read the full article hosted by Aspfree with pictures and explanations included.

“Microsoft first implemented the XMLHttpRequest object in Internet Explorer 5 for Windows as an ActiveX object. Engineers on the Mozilla project implemented a compatible native version for Mozilla 1.0 (and Netscape 7). Apple has done the same starting with Safari 1.2.

Similar functionality is covered in a proposed W3C standard, Document Object Model (DOM) Level 3 Load and Save Specification. In the meantime, growing support for the XMLHttpRequest object means that is has become a de facto standard that will likely be supported even after the W3C specification becomes final and starts being implemented in released browsers (whenever that might be).
Creating the Object

Creating an instance of the XMLHttpRequest object requires branching syntax to account for browser differences in the way instances of the object are generated. For Safari and Mozilla, a simple call to the object’s constructor function does the job:

var req = new XMLHttpRequest();

For the ActiveX branch, pass the name of the object to the ActiveX constructor:

var req = new ActiveXObject(”Microsoft.XMLHTTP”);

The object reference returned by both constructors is to an abstract object that works entirely out of view of the user. Its methods control all operations, while its properties hold, among other things, various data pieces returned from the server. ”

Read the full article from Apple’s own Developer corner.

“For frame based animation, we will stack our animation frames vertically, and some sizes related to height should be defined in pixels, that’s not condsidered good in terms of accessibility indeed as Internet Explorer users cannot change the sizes of fonts defined in pixels, but we need it for the simplicity of the tutorial. Stacking frames horizontally and setting the vertical positions to 50% would be “awesome”, but Opera has a bug I’ll explain later.

However, it is still possible to compensate for different sizes of text in animation with few modifications to our image design principles and code, which I may display in another article. Ironically, if you like to change, font-sizes on web pages, Opera is a superb alternative which doesn’t break pages while resizing, and works perfectly with this technique while allowing the users to read content with gigantic font sizes.

Preparing the images

In this example, each frame is 210*30px. The size of the frames does not necessarily have to be the same as the element(s), for example, anchors on this page are actually 150px wide. Likewise, they wouldn’t need to be of the same size height either, as you could go for such styles that would account for elements with different heights.

We will vertically stack all animation frames. Sadly, for best accessibility, stacking frames horizontally would have been better, as we could place the background image 50% vertically to account for different heights without having to compensate for that in our images; but Opera has problems with ultra wide background images so some frames go missing and background images are misplaced. One of the few times I am let down by Opera…”

Read the full article by Hesido complete with full examples and information about XHTML methods.

“Your Web server has a tough job. It must connect to databases, retrieve data, process it, format it into HTML, and then send it to the client. Increase the life of your server by reducing the load on it using XML and XSL. The eXtensible Stylesheet Language (or XML) is a style-sheet format for XML documents that is the counterpart to the Cascading Style Sheet (CSS) in HTML. By sending the XML and XSL to the client, and having the client create the HTML for you, your server can spend time doing other things, like processing credit card orders!

Requirements

Server and client should have the XML parser, version 3 from http://msdn.Microsoft.com/xml. The client should have IE 5 or higher.

Overview

An ASP page will connect to a database and retrieve the data. Then it will be converted into XML and sent to the client. The ASP page will associate an XSL URL in the data stream it sends to the client, and the XSL will have a CSS associated with it as well. Once the client receives the XML and fetches the associated XSL and CSS, the client will transform the XML into HTML.

To simplify the code, we won’t be using error checking, but you should use it in your production applications.”

Read the full article hosted by 15 Seconds. Your server will thank you.

Questions about when you should use images to enhance your web site. Wondering what a GIF actually is? Herman Drost has you covered: “When to use images for your web site - Navigation
Graphical buttons can link to other pages or resources.

Image Maps – this is a graphic that contains several links on it. It has several “hot spots” or invisible buttons, you can click on. For example you could have a photograph of your family and put a hot spot on each person’s face that links to that person’s web site.

Logos and Trademarks – your business or organization’s trademark are crucial for name recognition and branding.

Thumbnails – this is a small, “thumbnail-sized version of an image. When you click on it, you jump to another page with a larger version of the same image. The visitor can see many different, small images on the first page without having to wait for larger files of the larger images to load.

What are the different image file formats?
Web graphics can be categorized into two file formats:
bitmap and vector.

Bitmap – these are composed of individual values for each color
displayed. The larger the dimensions of the image, the larger
the associated file size will be for the same graphic. When
viewed with magnification, a bitmap resembles a series of little
squares, each of which has a color value that contributes to the
overall shape. Bitmaps have a very rough appearance when viewed
closely but form images when viewed from a distance.

Bitmaps are best suited for photos, drop-shadow effects and
soft, glowing or blurry edges.”

Read the full article hosted by Isitebuild.

Nobody’s perfect, but when you’re a web developer it sometimes seems that the whole world expects you to be. “DOCTYPE confusion.Completely missing, incorrect, or in the wrong place. I have seen HTML 4.0 Transitional used in documents containing XHTML markup as well as in documents, DOCTYPE declarations appearing after the opening tag, and incomplete DOCTYPES.

Why? Two reasons. First, it’s required, as stated in the W3C HTML 4.01 spec as well as in the W3C XHTML 1.0 spec. Second, modern web browsers use the specified DOCTYPE to decide which rendering mode to use. This is also known as “DOCTYPE switching”. For more consistent results across browsers, especially when using CSS, you’ll want browsers to use their “Standards compliance mode”. More info on DOCTYPE switching can be found in Fix Your Site With the Right DOCTYPE! and Activating the Right Layout Mode Using the Doctype Declaration.

A common way of styling something with CSS is to wrap it in a element with a class attribute and use that to hook up the styling. I’m sure we’ve all seen things like and why? It is, in most cases, completely unnecessary, has no semantic value, and just clutters the markup. Use heading elements for headings, put paragraphs in paragraph elements, mark up lists with HTML list elements. Use CSS to style those elements. If necessary, add class or id attributes.”

Read the full list of common web development mistakes and see if your web page has any of them.

“1. CSS font shorthand rule

When styling fonts with CSS you may be doing this:
font-size: 1em;
line-height: 1.5em;
font-weight: bold;
font-style: italic;
font-variant: small-caps;
font-family: verdana,serif;

There’s no need though as you can use this CSS shorthand property:
font: 1em/1.5em bold italic small-caps verdana,serif

Much better! Just a couple of words of warning: This CSS shorthand version will only work if you’re specifying both the font-size and the font-family. Also, if you don’t specify the font-weight, font-style, or font-varient then these values will automatically default to a value of normal, so do bear this in mind too.”

And that’s just the first. Read the full article at Evolt.org and master them all.

Stylus Studio features the world’s most powerful XSLT debugger — a requirement for building bug-free XSLT stylesheets and XML data transformation applications. Stylus Studio’s XSLT debugger gives you complete visibility and control over the XSLT transformation process, and it’s the only XSLT tool to support cross-XSLT-processor, cross-language XSLT debugging.

Debug XSLT using Popular XSLT Processors

Our XSLT Debugger is unique in its comprehensive support for XSLT debugging using all of the most common underlying XSLT processor, including MSXML, Xalan-J, System.XML (Microsoft.NET XSLT Processor), Saxon, and many others, in addition to supporting our own built-in, internal XSLT processor. Our Open XSLT Debugging Architecture in Stylus Studio’s XSLT Debugger enables you to reproduce and isolate exactly those stylesheet bugs you are encountering, with confidence. This is more helpful than other XML tools, which provide XSLT debuggers that exclusively support only their own proprietary XSLT processors. Stylus Studio lets you go with what you know — it’s standards-based, after all. Choosing an XSLT processor (illustrated below) is simply a matter choosing from a list of pre-configured options, or specifying the command line arguments needed to kick off an XSLT processor:

Choosing an XSLT Processor to use with the Stylus Studio XSLT Debugger

Finally! an XSLT debugger that can be used by all XSLT developers, regardless of their platform and programming language preferences — We think that’s the way it should be!

Set/Toggle XSLT Breakpoints

Stylus Studio allows you to easily set and toggle breakpoints anywhere in your XSLT stylesheet code (illustrated below). The red octagons in the left margin represent breakpoints. The yellow triangle shows the XSLT processor’s current state. You can set/toggle breakpoints from a toolbar or by typing the “F9″ key.

Setting a Breakpoint in an XSLT Stylesheet using the XSLT Debugger
Single Step-Through XSLT Stylesheets

The XSLT Debugger lets you step through the execution of an XSLT stylesheet, line-by-line, just as you would using a conventional software debugger. Using the XSLT Debugger toolbar, you can:

* Step-In: Execute the next line of XSLT stylesheet code.
* Step-Out: Return to the line of XSLT code that called the template you are in.
* Step-Over: Execute the the XSLT template being called, and return immediately.

Single-Stepping through an XSLT Stylesheet is illustrated here:

Executing an XSLT Stylesheet line-by-line using the XSLT Debugger
Inspect XSLT Variables & XSLT Parameters

Stylus Studio’s XSLT debugger has an XSLT Variables window that shows all of the XSLT variables and values that are in scope, relative to the XSLT processor’s current context. The contents of the XSLT Variables window changes dynamically as you step through the XSLT transformation process.

Analyzing XSLT Variables with the XSLT Debugger
Set Watches on XSLT Variables or XPath Expressions

Similarly, in addition to viewing all of the XSLT variables in scope, you can set watches on custom XSLT variables or any XPath expression. Because variables and XPath expressions are typically themselves tree fragments, you can easily expand/collapse them in the Watch window. The XSLT Watch window is helpful, for example, if a template rule isn’t firing and you suspect an incorrect XPath in the template-match expression.

Using the XSLT Debugger to set watches on XSLT Variables and XPath Expressions
XSLT Template Stack Window

The XSLT Template Stack window helps you keep track of where you are in the XSLT stylesheet; it’s analogous to the Call-Stack in a conventional software debugger. The Template Stack window is particularly useful for stylesheets that employ so-called “push-processing” (that is, where XSLT templates are defined, but not explicitly called; rather they are matched and fired by the XSLT processor’s default processing rules), which often results in a relatively deep XSLT template-stack.

Viewing the XSLT Debugger’s XSLT Template Stack
Support for Debugging Java XSLT Extension Functions

Stylus Studio is the only XSLT Debugger to support integrated debugging of any Java XSLT extension functions. This means that as you step through an XSLT stylesheet, Stylus Studio seamlessly steps through an extension function code in our Java IDE, passing any XSLT variables necessary to the Java Process, then, returns from the Java process, having passed back any return values to the XSLT processor. All of the debugging windows, such as the Variables window, Template Stack window, Watch window, all work in the Java IDE displaying the Java stack, Java variables, and Java watches. We think this is more useful than other XSLT debuggers that simply crash upon encountering an XSLT extension function.

XSLT Output Window

Stylus Studio’s XSLT debugger provides a XSLT Output window that displays the output of the XSLT processor in real time, as you walk through the XSLT transformation process. One of the helpful features included in the XSLT Output window is Backmapping — if you click on a line of output, Stylus Studio highlights the XSLT stylesheet source that generated that line of output. Backmapping is an invaluable tool for troubleshooting incorrect XSLT stylesheet output, and for answering the age-old question: “How did that get there?”. Other features include the ability to refresh the output, save the output to a file, compare different XSLT outputs (via a tabbed pane interface), and much more.

XSLT Debugger output console window
Configure and Save XSLT Debugging Scenarios

Stylus Studio allows you to create XSLT Scenarios — associations of XML documents, XSLT stylesheets, target outputs, and XSLT processors (and their respective configurations). Stylus Studio allows you to create such scenarios, save them, then easily switch between different debugging scenarios as you develop. Want to debug an XSLT stylesheet on both MSXML and Xalan-J? Scenarios make it easy.

source : http://www.stylusstudio.com/xslt_debugger.html

There are problems with using tables to lay out your web page, and web developer DC is more than happy to lay them out and provide an alternative. “Using tables to lay out a page can allow very complex designs (with very complex markup); it does not mean that the user need be aware that that is what he is looking at (although there have been sites built with tables which had visible, thick borders — very ugly, very 1997). Turning off the table borders (<table border=”0″>) allows the designer to build layouts as complicated as he might wish while the user sees (hopefully) a clean page without a hint of the skeleton holding it together.

There are, though, problems with using tables to control layout. The first problem is that it goes against the entire concept of the way HTML is supposed to work. I know, I know — I’ve said this before (and before, and before… ). It bears repeating, however: HTML is supposed to define the structure of a web page — this is a heading, this is a paragraph and so on. It is not supposed to, and not designed to, define the appearance of a web page.

Having said that, for quite some time there was literally nothing else a web designer could use but HTML, so it is understandable that anyone building a web page would grab with both hands whatever was available to lay out a page — <font> tags, the single-pixel GIF trick and using tables for layout being among the most widely used and abused.

The table element was never intended to be used for laying out a page. To state the obvious: the table element is for the tabular presentation of information. That is its sole legitimate function.”

Read the full article at the author’s personal web page and learn how to lay out your pages without using tables.

The technology resolves semantic ambiguities in the descriptions of Web service interfaces by combining information retrieval and semantic Web techniques. Information retrieval techniques are used to resolve the domain-independent relationships. For example, in this approach, semantic similarity is derived using an English thesaurus after “tokenization” and part-of-speech tagging of the names of the elements that describe the interfaces of Web services.

Semantic Web techniques are used to resolve domain-specific similarities. For example, the concepts used in a given domain (such as retail industry, health-care industry, etc.) and the relationships among them are modeled as a domain ontology. The Web services are annotated using semantic annotations from the domain ontologies in Web Services Semantics (WSDL-S) format. Then the ontological similarity of the semantic annotations associated with Web service descriptions is derived by inferring the domain ontology.

Matches from the two approaches are combined to determine an overall similarity score to help assess the quality of a Web service match to a given request. In cases where single services do not match a given request, the system can compose multiple services by employing artificial intelligence (AI) planning algorithms in order to fulfill a given request.

The WSDL-S mechanism for annotating Web services with semantics is based on an approach developed jointly by IBM and the University of Georgia. This approach was submitted to W3C in 2005 and is now the basis for the work of the new Semantic Annotations for WSDL (SAWSDL) Working Group.