Using ProcessingInstruction for Ajax

Implementing a specific function in JavaScript is not a walk in the park. Every developer has to consider each browser as each browser has different reaction to a certain command. If browser difference is not considered, the application might not be working well or would be completely buggy.

A good example for this is the ProcessingInstruction function in JavaScript. As the name suggests, this type of function in JavaScript provides instructions to the browser on how the specific node would be implemented. It could easily attach itself to the node and expect the specific node to be implemented according to the developer’s specification.

First Challenge – No Node Children

The ProcessingInstruction function could become your repetitive function in your Ajax based application. Since it has node children, the function will not have the ability implement itself to other nodes. If the developer wants to add the functionality, the function has to be called again.

There is a good reason why it should be this way – each ProcessingInstruction function is composed of different set of commands. This specific form of function is usually a combination of data type, form and point of reference for .xsl function. This is eventually treated as a node but instead of simplified data, it influences the data node.

Second Challenge – Mistaking Prolog for ProcessingInstruction

Because of the simplified look of ProcessingInstruction, there are developers who could regard some functions as ProcessingInstruction but actually a separate function with separate reactions.

One of the common confusion is based on Prolog which is usually implemented in the beginning of the application. This XML command looks like the ProcessingInstruction function but it’s actually a simple identifier in the application. Implementing prolog will just give developers the chance to help the browser identify the function.

Third Challenge – HTML Implementation

If you are thinking of implementing ProcessingInstruction function in HTML, think again. This type of function is only made to work with XML and it will probably stay that way for every. If you force yourself to work HTML in this type of function, you will run into a buggy application in Firefox and Opera. These browsers cannot read these functions and will probably ignore it.

In this case, IE provides a different interpretation. The reaction of IE actually for this function actually depends on the version. Version 5.5 looks at it as an element while 6 and 7 looks at it as a comment.

When the function is implemented as an element, there is a chance that it could have child nodes but still according to developer’s risk. When they are implemented as a comment, the chance of getting them to work as a function is minimal. But the mere fact that it tries to work with ProcessingInstruction function in HTML format could only mean improvement.

Firefox and Opera on the other hand doesn’t necessarily read this because there are a slew of functions available for developers which could be read in XML format. The ProcessingInstruction function is certainly a difficult function to deal with but as long as the reaction of the browser is understood, adoption is a lot easier.