Srivasta

What is System.out.println

2013-01-06T05:53:00.000-08:00

What is System.out.println

System.out.println prints the argument passed, into the System.out which is generally stdout.

System – is a final class and cannot be instantiated. Therefore all its memebers (fields and methods) will bestatic and we understand that it is an utility class. As per javadoc, “…Among the facilities provided by theSystem class are standard input, standard output, and error output streams; access to externally defined properties and environment variables; a means of loading files and libraries; and a utility method for quickly copying a portion of an array…”
out – is a static member field of System class and is of type PrintStream. Its access specifiers are public final. This gets instantiated during startup and gets mapped with standard output console of the host. This stream is open by itself immediately after its instantiation and ready to accept data. When running a program from windows command line, it is the standard console.
println – println prints the argument passed to the standard console and a newline. There are multiple println methods with different arguments (overloading). Every println makes a call to print method and adds a newline. print calls write() and the story goes on like that.

Change out of System.out.println

‘out’ object can be customized. out gets initialized by java runtime environment at startup and it can be changed by developer during execution. Instead of standard output, in default cases when you run a program through command line, the output is printing in the same command window. We can change that behavior using setOut method as below. In the following example, I have redirected the output to a text file in the same directory.

public class ChangeOut {

public static void main(String args[]) {

try {

System.setOut(new PrintStream(new FileOutputStream("log.txt")));

System.out.println("Now the output is redirected!");

} catch(Exception e) {}

}

System.out.println vs loggers like Log4j

Log4J has mulitple levels for logging. If we are writing a real short program, just for experimental/learning purposes SOPs are fine. When we are developing a production quality software project, we should be aware that a professional logger should be used and SOPs should be avoided. Why?

Flexibility: a professional logger like log4j provides different levels for logging. We can seggregate the log message accordingly. For example, X messages should be printed only on PRODUCTION, Y messages should be printed on ERROR, etc.
Configurability: in just one parameter change we can switch off all the logging statements.
Maintainability: imagine if we have hundreds of SOPs littered all through the application, it would be difficult to maintain the program over a period.
Granularity: In an application, every single class can have a different logger and controlled accordingly.
Utility: Option for redirecting the message is limited in System.out, but in case of a logger you have appenders which provides numerous options. We can even create a custom ouput option and redirect it to that.

· Having said all the above, we still use System.out.println for logging and debugging. Which should be strictly avoided. This is driven by (bad)habit. I want to share how a habit became a convention. In this case its a good habit. Its using ‘i’, ‘j’ as index in for-loop. In FORTRAN language, we need not declare integer variables. Variable names that start with i, j, k, l, m and n are integer variables. So, FORTRAN developers named for-loop index with i,j,k and that habit carried on to other languages. Just a habit and became a good convention!

· System.out.println and Performance

· There is a general notion that SOPs are bad in performance. When we analyze deeply, the sequence of calls are like println -> print -> write() + newLine(). This sequence flow is an implementation of Sun/Oracle JDK. Both write() and newLine() contains a synchronized block. Synchronization has a little overhead, but more than that the cost of adding characters to the buffer and printing is high.

· When we run a performance analysis, run multiple number of SOP and record the time, the execution duration increases proportionally. Performance degrades when we print more that 50 characters and print more than 50,000 lines.

· It all depends on the scenario we use it. Whatever may be the case, do not use System.out.println for logging to stdout.

· Static Import to Shorten SOP

· Someone complained that System.out.println is a loooong statement to print something. static import may shorten it a bit but it is not recommended, because it results in poor readability. I am just using this situation to explain static import and avoid using it in the below scenario.

import static java.lang.System.out;

public class ShortSOP {

public static void main(String[] args) {

out.println("Hello, world");

}

· In Eclipse you have programmed shortcuts like ctrl + spac to help you out.

· System.err and System.in

· As a related section, I wish to discuss about ‘err’ and ‘in’. ‘in’ is associated with InputStream. Opposite to ‘out’, ‘in’ is used to get input from standard console generally keyboard.
‘err’ is associated with PrintStream and prints the argument to the standard error output stream. When you use eclipse kind of IDE you can see the differene in ouput between ‘out’ and ‘err’.

public class InOutErr {

public static void main(String args[]) {

try {

BufferedReader reader = new BufferedReader(System.in);

String filename = reader.readLine();

InputStream input = new FileInputStream(filename);

System.out.println("File opened...");

} catch (IOException e){

System.err.println("Where is that file?");

}

Performance Monitoring in Cloud Systems

2012-07-20T06:33:00.000-07:00

Performance Monitoring in Cloud Systems

Cloud computing promotes the idea of utility computing by enabling scaling of resources based on demand. The basic premise on which cloud economics is built on is sharing of resources amongst multiple users, based on the requirement. Many cloud solutions are adopting virtualization as the enabling technology to support cloud services on-demand. To enable features like real-time responsiveness to applications on clouds with desired security and privacy, the cloud system architecture must support isolation properties on shared resources. Current system virtualization architectures do not support concurrency on all system resources. As a result, different virtualization architectures introduce differences in resource utilization for different workloads. In this talk, a brief introduction to system virtualization architectures is given with a view towards explaining the impact on application performance, specifically the I/O workloads.

Moving applications from non-virtualized to virtualized platforms could change the resource requirements, particularly for I/O workloads, to achieve equivalent performance. This change depends significantly on the virtualization architecture used. Hence, to measure the impact on an application, it is mandatory to have appropriate monitoring tools as well as frameworks on the cloud systems that can give fine-grained information on not just the resources used but also, application specific metrics.

Monitoring of infrastructural resources in clouds plays a crucial role in providing application guarantees like performance, availability, and security. Monitoring is important from two perspectives - the cloud-user and the service provider. The cloud user's interest is in doing an analysis to arrive at appropriate Service-level agreement (SLA) demands and the cloud provider's interest is to assess if the demand can be met. To support this, a monitoring framework is necessary particularly since cloud hosts are subject to varying load conditions. To illustrate the importance of such a framework, in this talk an example of performance being the Quality of Service (QoS) requirement is illustrated to show how inappropriate provisioning of resources may lead to unexpected performance bottlenecks. Existing monitoring frameworks are examined to bring out the motivation for building much more powerful monitoring frameworks. The talk concludes with a discussion on proposed distributed monitoring framework, which enables fine grained monitoring for applications.

J Lakshmi

Principal Research Scientist,

SERC, Indian Institute of Science, Bangalore - 12, India

j2me-2

2012-06-26T09:37:00.001-07:00

j2me part -2

Definitions

Java Platform, Micro Edition, or Java ME, is a Java platform designed for mobile devices and embedded systems. Target devices range from industrial controls to mobile phones (especially feature phones) and set-top boxes. Java ME was formerly known as Java 2 Platform, Micro Edition (J2ME).

Sun Microsystems defines J2ME as "a highly optimized Java run-time environment targeting

a wide range of consumer products, including pagers, cellular phones, screen-phones, digital set-top boxes and car navigation systems."

Announced in June 1999 at the Java One Developer Conference, J2ME brings the cross-platform functionality of the Java language to smaller devices, allowing mobile wireless devices to share applications. With J2ME, Sun has adapted the Java platform for consumer products that incorporate or are based on small computing devices.

Differences Between Java and J2ME

Major Differences are :

· Floating-point math is missing in J2ME. MIDlet cannot use any floating-point data types or calculations.

· Absence of finalize() method in J2ME.

· Reduced number of error-handling exceptions in J2ME.

· JVM for small computing devices requires a custom class loader that is supplied by the device manufacturer and cannot be replaced or modified.

· We cannot group threads. All threads are handled at the object level.

· The class file verification is replaced with two processes called Preverificaton andValidation. Preverification occurs prior to loading the MIDLet’s and Validation occurs after loading the MIDLet.

j2me

2012-06-15T23:17:00.002-07:00

Part-1

Which company was behind creating and maintaining Java?

Sun Microsystems

What was the original name for Java?

Oak

What is the name of the inventor (or father) of Java?

James Gosling

Java code that is embedded as a small application in a web page is called a(n)...?

Applet

Java can run on any computer platform that has a ...?

Java Virtual Machine

The Java API intended for business and server 3-tier applications is called?

Java 2, Enterprise Edition

What does AWT stand for?

Abstract Window Toolkit

Which of the following keywords are found in Java but not in C++?

final

Which of the following keywords are in C++ but not in Java?

virtual

What is the name of the class that all Java classes inherit (directly or indirectly) from?

Object

Cloud Security

2012-04-16T09:49:00.001-07:00

Cloud Security Is ...

•The response to a familiar set of security challenges that manifest differently in the cloud. New technologies and fuzzier boundaries surrounding the data center require a different approach.

• A set of policies, technologies, and controls designed to protect data and infrastructure from attack and enable regulatory compliance.

•Layered technologies that create a durable security net or grid. Security is more effective when layered at each level of the stack and integrated into a common management framework.

•The joint responsibility of your organization and its cloud provider(s). Depending on the cloud delivery model and services you deploy, responsibility for security comes from both parties.

Three Major Trends That Impact Cloud Security

To manage cloud security in today’s world, you need a solution that helps you address threats to enterprise data and infrastructure, including the major trends you are up against.

Changing attackers and threats: Threats are no longer the purview of isolated hackers looking for personal fame. More and more, organized crime is driving well-resourced, sophisticated, targeted attacks for financial gain.

Evolving architecture technologies: With the growth of virtualization, perimeters and their controls within the datacenter are in flux, and Data is no longer easily constrained or physically isolated and protected.

Dynamic and challenging regulatory environment: Organizations—and their IT departments—face on going burdens of legal and regulatory compliance with increasingly prescriptive demands and the high penalties for noncompliance or breaches. Examples of regulations include Sarbanes-Oxley(SOX), Payment Card Industry (PCI), and the Health Insurance Portability and Accountability Act (HIPAA).

Cloud Security Isn’t …

• A one-size-fits-all solution that can protect all your IT assets. In addition to different cloud delivery models, the cloud services you deploy will most likely require more than one approach to security.

•A closed-perimeter approach or a “fill-the-gap” measure. Organizations can no longer rely on firewalls as a single point of control, and cobbling together security solutions to protect a single vulnerability may leave you open in places you don’t suspect.

•Something you can assume is provided at the level you require by your cloud service providers. Make sure you spell out and can verify what you require.

searching ini Files Useing BAT file

2012-04-16T09:33:00.001-07:00

Display all the files in C drive its very use full check once
save this file with .BAT

@echo off
echo blanking screen .......
cls
echo searching ini's
@dir c:\*.ini /s/w
echo .... Scared ?
pause

JSP Server pages

2012-04-16T09:24:00.001-07:00

The Department of Information Technology

KPR Krishnachaitanya

Java Server Pages

What Is Java Server Pages?
JavaServer Pages is a tec hnology for developing web pages that include dynamic content. Unlike a plain HTML page, which contains static content that always remains the same, a JSP page can change its content based on any number of variable items, including the identity of the user, the user's browser type, information provided by the user, and selections made by the user.
A JSP page contains standard markup language elements, such as HTML tags, just like a regular web page. However, a JSP page also c ontains special JSP elements that allow the server to insert dynamic content in the page. JSP elements can be used for a variety of purposes, such as retrieving information from a database or registering user preferences. When a user asks for a JSP page, the server executes the JSP elements, merges the results with the static parts of the page, and sends the dynamically composed page back to the browser.

Why Use JSP?
In the early days of the Web, the Common Ga teway Interface (CGI) was the only tool for developing dynamic web content. However, CG I is not an efficient solution. For every request that comes in, the web server has to create a new operating-system process, load an interpreter and a script, execute the script, and then tear it all down again. This is very taxing for the server and doesn't scale well when the amount of traffic increases.
JSP tackles the problem from the other direction. Instead of embedding HTML in programming code, JSP lets you embed special active elements into HTML pages. These elements look similar to HTML

elements, but behind the scenes they are actually componentized Java programs that the server executes when a user requests the page.

<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
<html>
<body bgcolor="white">

<jsp:useBean id="clock" class="java.util.Date" />
<c:choose>
   <c:when test="${clock.hours < 12}">
     <h1>Good morning!</h1>
   </c:when>
   <c:when test="${clock.hours < 18}">
     <h1>Good day!</h1>
   </c:when>
   <c:otherwise>
     <h1>Good evening!</h1>
   </c:otherwise>
</c:choose>
Welcome to our site, open 24 hours a day.
</body>
</html>

This page inserts a different message to the user based on the time of day: "Good morning!" if the local time is before 12 P.M., "Good day! " if between 12 P.M. and 6 P.M., and "Good evening!" otherwise. When a user asks for this page, the JSP-enabled web server executes the logic represented by the highlighted JSP elements and creates an HTML page that is sent back to the user's browser. For example, if the current time is 8:53 P.M., the resulting page sent from the server to the browser looks like this:

<html>
<body bgcolor="white">

<h1>Good evening!</h1>
   Welcome to our site, open 24 hours a day.
</body>
</html>

Compilation
Another benefit that is important to mention is that a JSP page is always compiled before it's processed by the server. Remember that older technologies such as CGI/Perl require the server to load an interpreter and the target script each time the page is requested. JSP gets around this problem by compiling each JSP page into executable code the first time it's requested (or on demand), and invoking the resulting code directly on all subsequent requests.When coupled with a persistent Java virtual machine on a JSP-enabled web server, this allowsthe server to handle JSP pages much faster.
The Anatomy of a JSP Page
A JSP page is simply a regular web page with JSP elements for generating the parts that differ for each request
Template text and JSP elements

Everything in the page that isn't a JSP element is called template text. Template text can be any text: HTML, WML, XML, or even plain text. Since HTML is by far the most common web-page language in use today, most of the descriptions and examples in this book use HTML, but keep in mind that JSP has no dependency on HTML; it can be used with any markup language. Template text is always passed straight through to the browser. When a JSP page request is processed, the template text and dynamic content generated by the JSP elements are merged, and the result is sent as the response to the browser.

JSP Processing
Just as a web server needs a servlet container to provide an interface to servlets, the server needs a JSP container to process JSP pages. The JSP cont ainer is responsible for intercepting requests for JSP pages. To process all JSP elements in the page, the container first turns the JSP page into a servlet (known as the [ JSP page implementation class). The conversion is pretty straightforward; all template text is converted to println( ) statements similar to the ones in the handcoded servlet shown in Example 3-1, and all JSP elements are converted to Java code that implements the corresponding dynamic behavior. The container then compiles the servlet class.Converting the JSP page to a servlet and compiling the servlet form the translation phase. The JSP container initiates the translation phase for a page automatically when it receives the first request for the page. Since the translation phase takes a bit of time, the first user to request a JSP page notices a slight delay. The translation phase can also be initiated explicitly; this is referred to as precompilation of a JSP page. Precompiling a JSP page is a way to avoid hitting the first user with this delay.   The JSP container is also responsible for i nvoking the JSP page implementation class (the generated servlet) to process each request and generate the response. This is called the request processing phase .

JSP page translation and processing phases

As long as the JSP page remains unchanged, any subsequent request goes straight to the request processing phase (i.e., the container simply executes the class file). When the JSP page is modified, it goes through the translation phase again before entering the request processing phase. The JSP container is often implemented as a servlet configured to handle all requests for JSP pages. In fact, these two containers -- a serv let container and a JSP container -- are often combined in one package under the name web container .

So in a way, a JSP page is really just another way to write a servlet without having to be a Java programming wiz. Except for the translation phase, a JSP page is handled exactly like a regular servlet: it's loaded once and called repeat edly, until the server is shut down. By virtue of being an automatically generated servlet, a JSP page inherits all the advantages of a servlet described in platform and vendor independence, integration, efficiency, scalability, robustness, and security.

JSP Elements
There are three types of JSP elements you can use: directive , action , and scripting .

Directive elements

specify information about the page itself that remains the same between requests -- for example, if session tracking is required or not, buffering requirements, and the name of a page that should be used to report errors, if any.

Standard action elements

Action elements typically perform some action based on information that is required at the exact time the JSP page is requested by a browser. An action can, for instance, access parameters sent with the request to do a database lookup. It can also dynamically generate HTML, such as a table filled with information retrieved from an external system.

3.Custom action elements a nd the JSP Standard Tag Library
In addition to the standard actions, the JSP specification includes a Java API a programmer can use to develop custom actions to extend the JSP language. Th e JSP Standard Tag Library (JSTL) is such an extension, w ith the special status of being defined by a formal specification from Sun and typically bundled with the JSP c ontainer. JSTL contains action elements for processes needed in most JSP applications, such as conditional processing, database access, internationalization, and more.

3.Scripting elements
Scripting elements, shown in Table allow you to add small pieces of code (typically Java code) in a JSP page, such as an if statement to generate different HTML depending on a certain condition. Like actions, they are also executed when the page is requested. You should use scripting elements with extreme care: if you embed too much code in your JSP pages, you will end up with the same kind of maintenance problems as with servlets embedding HTML.

JDBC Driver

A JDBC driver is a software component enabling a Java application to interact with a database. JDBC drivers are analogous to ODBC drivers, ADO.NET data providers, and OLE DB providers. To connect with individual databases, JDBC (the Java Database Connectivity API) requires drivers for each database. The JDBC driver gives out the connection to the database and implements theprotocol for transferring the query and result between client and database.
JDBC drivers are divided into four types or levels. The different types of jdbc drivers are:
Type 1: JDBC-ODBC Bridge driver (Bridge)Type 2: Native-API/partly Java driver (Native)Type 3: AllJava/Net-protocol driver (Middleware)Type 4: All Java/Native-protocol driver (Pure)
Type 1 JDBC Driver
JDBC-ODBC Bridge driver
The Type 1 driver translates all JDBC calls into ODBC calls and sends them to the ODBC driver. ODBC is a generic API. The JDBC-ODBC Bridge driver is recommended only for experimental use or when no other alternative is available.

Type 1: JDBC-ODBC Bridge
Advantage
The JDBC-ODBC Bridge allows access to almost any database, since the database's ODBC drivers are already available.
Disadvantages
1. Since the Bridge driver is not written fully in Java, Type 1 drivers are not portable.
2. A performance issue is seen as a JDBC call goes through the bridge to the ODBC driver, then to the database, and this applies even in the reverse process. They are the slowest of all driver types.
3. The client system requires the ODBC Installation to use the driver.
4. Not good for the Web.
Type 2 JDBC Driver
Native-API/partly Java driver
The distinctive characteristic of type 2 jdbc drivers are that Type 2 drivers convert JDBC calls into database-specific calls i.e. this driver is specific to a particular database. Some distinctive characteristic of type 2 jdbc drivers are shown below. Example: Oracle will have oracle native api.

Type 2: Native api/ Partly Java Driver
Advantage
The distinctive characteristic of type 2 jdbc drivers are that they are typically offer better performance than the JDBC-ODBC Bridge as the layers of communication (tiers) are less than that of Type
1 and also it uses Native api which is Database specific.
Disadvantage
1. Native API must be installed in the Client System and hence type 2 drivers cannot be used for the Internet.
2. Like Type 1 drivers, it’s not written in Java Language which forms a portability issue.
3. If we change the Database we have to change the native api as it is specific to a database
4. Mostly obsolete now
5. Usually not thread safe.
Type 3 JDBC Driver
All Java/Net-protocol driver
Type 3 database requests are passed through the network to the middle-tier server. The middle-tier then translates the request to the database. If the middle-tier server can in turn use Type1, Type 2 or Type 4 drivers.

Type 3: All Java/ Net-Protocol Driver
Advantage
1. This driver is server-based, so there is no need for any vendor database library to be present on client machines.
2. This driver is fully written in Java and hence Portable. It is suitable for the web.
3. There are many opportunities to optimize portability, performance, and scalability.
4. The net protocol can be designed to make the client JDBC driver very small and fast to load.
5. The type 3 driver typically provides support for features such as caching (connections, query results, and so on), load balancing, and advanced
system administration such as logging and auditing.
6. This driver is very flexible allows access to multiple databases using one driver.
7. They are the most efficient amongst all driver types.Disadvantage
It requires another server application to install and maintain. Traversing the recordset may take longer, since the data comes through the backend server.
Type 4 JDBC Driver
Native-protocol/all-Java driver
The Type 4 uses java networking libraries to communicate directly with the database server.
Type 4: Native-protocol/all-Java driver
Advantage
1. The major benefit of using a type 4 jdbc drivers are that they are completely written in Java to achieve platform independence and eliminate deployment administration issues. It is most suitable for the web.
2. Number of translation layers is very less i.e. type 4 JDBC drivers don't have to translate database requests to ODBC or a native connectivity interface or to pass the request on to another server, performance is typically quite good.
3. You don’t need to install special software on the client or server. Further, these drivers can be downloaded dynamically.
Disadvantage

With type 4 drivers, the user needs a different driver for each database.
Cookies
What are cookies? A "cookie" is a small piece of information sent by a web server to store on a web browser so it can later be read back from that browser. This is useful for having the browser remember some specific information. What are they used for ? An example is when a browser stores your passwords and user ID's. They are also used to store preferences of start pages, both Microsoft and Netscape use cookies to create personal start pages. Common cookies which companies use are find info are listed below:
Site Personalization. This is one of the most beneficial uses, let's say a person comes to the MSNBC site but doesn't want to see any sports news. They allow people to select this as an option, from then on (until the cookie expires) they wouldn't see sports news. This is also usefull for start pages. Website Tracking. Here is a hot button! A lot of people think it is an invasion of privacy, if a web site designer wanted to see what interests them. Site tracking can show you "Dead End Paths", places in your website that people go to and then wander off because they don't have any more interesting links to hit. It can also give you more accurate counts of how many people have been to pages on your site. You could differentiate 50 unique people seeing your site from one person hitting the reload button 50 times.

Targeted Marketing. This is probably one of the main uses of cookies, they can be used to build up a profile of where you go what adverts you click on, this information is then used to target adverts at you, which they think are of interest, companies also use cookies to store which adverts have been displayed so the same advert does not get displayed twice. Doubleclick's use of cookies. User ID's. In Internet Explorer the first part of the cookie is your windows log in name, It's not certain if this is passed on to the server. How Do They Work A command line in the HTML of a document tell the browser to set a cookie of a certain name or value. Here is an example of some script used to set a cookie. Set-Cookie: NAME=VALUE; expir es=DATE; path=PATH; domain=DOMAIN_NAME; secure Cookies are usually run from CGI scripts, but they can also be set or read by Javascript. Security? An HTTP Cookie cannot be used to get data from your hard drive, get your email address or steal sensitive information about your person. Early implementations of Java and JavaScript could allow people to do this but for the most part these security leaks have been plugged. But HTTP Cookie can be used to track where you travel over a particular site, This site tracking can be easily done without using cookies as well, using cookies just makes the tracking data a little more consistent. If you want to disallow cookies you can do so with version 3.0 or greater of Netscape. Go to the Options Menu Select the Network Preferences Menu Item From the window that appears Select Protocols Locate the Section Show an Alert Before Check the box labeled Accepting a Cookie From now on you will get an Alert box telling you that a server is trying to set a cookie at your browser. It will tell you what the cookie value is and how long it will last before it is deleted
There are two main types of cookies: Session Cookies and Permanent Cookies.

Session Cookies

Session cookies are stored in memory during the applet or application session. Session cookies expire when the applet or application exits and are automatically deleted. These cookies usually store a session ID that is not personally identifiable to users, allowing the user to move from page to page without having to log-in repeatedly. They are widely used by commercial web sites (for example, to keep track of items that a consumer has added to a shopping cart.)

Permanent Cookies

Permanent cookies are stored in persistent storage and are not deleted when the application exits. They are deleted when they expire. They can retain user preferences for a particular web site, allowing those preferences to be used in future sessions. Permanent cookies can be used to identify individual users, so they may be used by web sites to analyze users' surfing behavior within the web site. These cookies can also be used to provide information about the numbers of visitors, the average time spent on a particular page, and the general performance of the web site. They are usually configured to keep track of users for a prolonged period of time, in some cases many years into the future.

HttpOnly cookie
The HttpOnly cookie is supported by most modern browsers. On a supported browser, an HttpOnly session cookie will be used only when transmitting HTTP (or HTTPS) requests, thus restricting access from other, non-HTTP APIs (such as JavaScript). This restriction mitigates but does not eliminate the threat of session cookie theft via cross-site scripting (XSS).This feature applies only to session-management cookies, and not other browser cookies.
Third-party cookie
First-party cookies are cookies set with the same domain (or its subdomain) in your browser's address bar. Third-party cookies are cookies being set with different domains from the one shown on the address bar (i.e. the web pages on that domain may feature content from a third-party domain - e.g. an advertisement run by www.advexample.com showing advert banners). (Privacy setting options in most modern browsers allow you to block third-party tracking cookies).
For example: Suppose a user visits www.example1.com, which sets a cookie with the domain ad.foxytracking.com. When the user later visits www.example2.com, another cookie is set with the domain ad.foxytracking.com. Eventually, both of these cookies will be sent to the advertiser when loading their ads or visiting their website. The advertiser can then use these cookies to build up a browsing history of the user across all the websites this advertiser has footprints on.
Supercookie
A "supercookie" is a cookie with a public suffix domain, like .com, .co.uk or k12.ca.us
Most browsers, by default, allow first-party cookies—a cookie with domain to be the same or sub-domain of the requesting host. For example, a user visiting www.example.com can have a cookie set with domain www.example.com or .example.com, but not .com. A supercookie with domain .com would be blocked by browsers; otherwise, a malicious website, like attacker.com, could set a supercookie with domain .com and potentially disrupt or impersonate legitimate user requests to example.com. The Public Suffix List is a cross-vendor initiative to provide an accurate list of domain name suffixes changing.Older versions of browsers may not have the most up-to-date list, and will therefore be vulnerable to certain supercookies.
The term "supercookies" is erroneously used in the media for tracking technologies that do not rely on HTTP cookies. Two such "supercookie" mechanisms were found on Microsoft websites: cookie syncing that respawned MUID cookies, and ETag cookies. Due to media attention, Microsoft later disabled this code:
In response to recent attention on "supercookies" in the media, we wanted to share more detail on the immediate action we took to address this issue, as well as affirm our commitment to the privacy of our customers. According to researchers, including Jonathan Mayer at Stanford University, "supercookies" are capable of re-creating users' cookies or other identifiers after people deleted regular cookies. Mr. Mayer identified Microsoft as one among others that had this code, and when he brought his findings to our attention we promptly investigated. We determined that the cookie behavior he observed was occurring under certain circumstances as a result of older code that was used only on our own sites, and was already scheduled to be discontinued. We accelerated this process and quickly disabled this code. At no time did this functionality cause Microsoft cookie identifiers or data associated with those identifiers to be shared outside of Microsoft.

Zombie cookie
A zombie cookie is any cookie that is automatically recreated after a user has deleted it. This is accomplished by a script storing the content of the cookie in some other locations, such as the local storage available to Flash content, HTML5 storages and other client side mechanisms, and then recreating the cookie from backup stores when the cookie's absence is detected.
Session Tracking Methods
Following answer is applicable irrespective of the language and platform used. Before we enter into session tracking, following things should be understood.
What is a session?
A session is a conversation between the server and a client. A conversation consists series of continuous request and response.
Why should a session be maintained?
When there is a series of continuous request and response from a same client to a server, the server cannot identify from which client it is getting requests. Because HTTP is a stateless protocol.
When there is a need to maintain the conversational state, session tracking is needed. For example, in a shopping cart application a client keeps on adding items into his cart using multiple requests. When every request is made, the server should identify in which client’s cart the item is to be added. So in this scenario, there is a certain need for session tracking.
Solution is, when a client makes a request it should introduce itself by providing unique identifier every time. There are five different methods to achieve this.
Session tracking methods:

User authorization

Hidden fields

URL rewriting

Cookies

Session tracking API

The first four methods are traditionally used for session tracking in all the server-side technologies. The session tracking API method is provided by the underlying technology (java servlet or PHP or likewise). Session tracking API is built on top of the first four methods.
1. User Authorization
Users can be authorized to use the web application in different ways. Basic concept is that the user will provide username and password to login to the application. Based on that the user can be identified and the session can be maintained.
2. Hidden Fields
<INPUT TYPE=”hidden” NAME=”technology” VALUE=”servlet”>
Hidden fields like the above can be inserted in the webpages and information can be sent to the server for session tracking. These fields are not visible directly to the user, but can be viewed using view source option from the browsers. This type doesn’t need any special configuration from the browser of server and by default available to use for session tracking. This cannot be used for session tracking when the conversation included static resources lik html pages.
3. URL Rewriting
Original URL: http://server:port/servlet/ServletName
Rewritten URL: http://server:port/servlet/ServletName?sessionid=7456
When a request is made, additional parameter is appended with the url. In general added additional parameter will be sessionid or sometimes the userid. It will suffice to track the session. This type of session tracking doesn’t need any special support from the browser. Disadvantage is, implementing this type of session tracking is tedious. We need to keep track of the parameter as a chain link until the conversation completes and also should make sure that, the parameter doesn’t clash with other application parameters.
4. Cookies
Cookies are the mostly used technology for session tracking. Cookie is a key value pair of information, sent by the server to the browser. This should be saved by the browser in its space in the client computer. Whenever the browser sends a request to that server it sends the cookie along with it. Then the server can identify the client using the cookie.
In java, following is the source code snippet to create a cookie:
Cookie cookie = new Cookie(“userID”, “7456″);
res.addCookie(cookie);
Session tracking is easy to implement and maintain using the cookies. Disadvantage is that, the users can opt to disable cookies using their browser preferences. In such case, the browser will not save the cookie at client computer and session tracking fails.
5. Session tracking API
Session tracking API is built on top of the first four methods. This is inorder to help the developer to minimize the overhead of session tracking. This type of session tracking is provided by the underlying technology. Lets take the java servlet example. Then, the servlet container manages the session tracking task and the user need not do it explicitly using the java servlets. This is the best of all methods, because all the management and errors related to session tracking will be taken care of by the container itself.
Every client of the server will be mapped with a javax.servlet.http.HttpSession object. Java servlets can use the session object to store and retrieve java objects across the session. Session tracking is at the best when it is implemented using session tracking api.

Servlet program to display date
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
public class date extends
HttpServlet
{
        public void doGet (HttpServletRequest request, HttpServletResponse response)
throws
ServletException,IOException
        {
        PrintWriter pw = response.getWriter();
  Date today =
new Date();
  pw.println("<html>"+"<body><h1>Today
Date is</h1>");
  pw.println("<b>"+
today+"</b></body>"+ "</html>");
}
}
web.xml
<web-app>
<servlet>
<servlet-name>DateServlet</servlet-name>
<servlet-class>myservlets.DateServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DateServlet</servlet-name>
<url-pattern>/DateServlet</url-pattern>
</servlet-mapping>
</web-app>


Session Tracking
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
public class ShowSession extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Session Tracking Example";
HttpSession session = request.getSession(true);
String heading;
Integer count = (Integer)session.getAttribute("count");
if (count == null) {
count = new Integer(0);
heading = "Session Tracking Example";
}
else {
heading = "Session Tracking Example";
count = new Integer(count.intValue() + 1);
}
session.setAttribute("count", count);
out.println("</html><head><title>"+title+"</title></head><body>" +
"<h1 align=\"\">" + heading + "</H1>\n" +
"<h2></h2>\n" +
"<table border=1 align=\"\">\n" +
            "<tr>"+"<TR bgcolor=\"#9999966\">\n"+
"<th>SessionTracking</th>"+

"<th>Time period</th>" +
"</tr>" +
"<tr>" +
"<td>ID</td>" +
"<td>" + session.getId() + "</td>" +
"</tr>" +
"<tr>" +
"<td>Current Time</td>" +
" <td>" + new Date(session.getCreationTime()) + "</td>" +
"</tr>" +
"<tr>" +
"<td>Time of Last Access</td>" +
" <td>" + new Date(session.getLastAccessedTime()) + "</td>" +
"</tr>" +
"<tr>" +
"<td>Number of Previous Accesses</td>" +
" <td>" + count + "</td>" +
"</tr>"+
"</table>" +
"</body></html>");
}
   public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}

Web.xml
Web.xml<?xml version="1.0" encoding="ISO-8859-1"?>


<web-app>
<servlet>
<servlet-name>ShowSession</servlet-name>
<servlet-class>ShowSession</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ShowSession</servlet-name>
<url-pattern>/ShowSession</url-pattern>
</servlet-mapping>
</web-app>

UML

2012-04-14T19:35:00.000-07:00

Association, Aggregation, Composition, Abstraction, Generalization, Realization, Dependency

These terms signify the relationships between classes. These are the building blocks of object oriented programming and very basic stuff. But still for some, these terms look like Latin and Greek. Just wanted to refresh these terms and explain in simpler terms.

Association

Association is a relationship between two objects. In other words, association defines the multiplicity between objects. You may be aware of one-to-one, one-to-many, many-to-one, many-to-many all these words define an association between objects. Aggregation is a special form of association. Composition is a special form of aggregation.

Example: A Student and a Faculty are having an association.

Aggregation

Aggregation is a special case of association. A directional association between objects. When an object ‘has-a’ another object, then you have got an aggregation between them. Direction between them specified which object contains the other object. Aggregation is also called a “Has-a” relationship.

Composition

Composition is a special case of aggregation. In a more specific manner, a restricted aggregation is called composition. When an object contains the other object, if the contained object cannot exist without the existence of container object, then it is called composition.

Example: A class contains students. A student cannot exist without a class. There exists composition between class and students.

Difference between aggregation and composition

Composition is more restrictive. When there is a composition between two objects, the composed object cannot exist without the other object. This restriction is not there in aggregation. Though one object can contain the other object, there is no condition that the composed object must exist. The existence of the composed object is entirely optional. In both aggregation and composition, direction is must. The direction specifies, which object contains the other object.

Example: A Library contains students and books. Relationship between library and student is aggregation. Relationship between library and book is composition. A student can exist without a library and therefore it is aggregation. A book cannot exist without a library and therefore its a composition. For easy understanding I am picking this example. Don’t go deeper into example and justify relationships!

Abstraction

Abstraction is specifying the framework and hiding the implementation level information. Concreteness will be built on top of the abstraction. It gives you a blueprint to follow to while implementing the details. Abstraction reduces the complexity by hiding low level details.

Example: A wire frame model of a car.

Generalization

Generalization uses a “is-a” relationship from a specialization to the generalization class. Common structure and behaviour are used from the specializtion to the generalized class. At a very broader level you can understand this as inheritance. Why I take the term inheritance is, you can relate this term very well. Generalization is also called a “Is-a” relationship.

Example: Consider there exists a class named Person. A student is a person. A faculty is a person. Therefore here the relationship between student and person, similarly faculty and person is generalization.

Realization

Realization is a relationship between the blueprint class and the object containing its respective implementation level details. This object is said to realize the blueprint class. In other words, you can understand this as the relationship between the interface and the implementing class.

Example: A particular model of a car ‘GTB Fiorano’ that implements the blueprint of a car realizes the abstraction.

Dependency

Change in structure or behaviour of a class affects the other related class, then there is a dependency between those two classes. It need not be the same vice-versa. When one class contains the other class it this happens.

Example: Relationship between shape and circle is dependency.

Differentiate JVM JRE JDK JIT

2012-04-14T19:16:00.002-07:00

Differentiate JVM JRE JDK JIT

Java Virtual Machine (JVM) is an abstract computing machine. Java Runtime Environment (JRE) is an implementation of the JVM. Java Development Kit (JDK) contains JRE along with various development tools like Java libraries, Java source compilers, Java debuggers, bundling and deployment tools.

JVM becomes an instance of JRE at runtime of a java program. It is widely known as a runtime interpreter. The Java virtual machine (JVM) is the cornerstone on top of which the Java technology is built upon. It is the component of the Java technology responsible for its hardware and platform independence. JVM largely helps in the abstraction of inner implementation from the programmers who make use of libraries for their programmes from JDK.

Diagram to show the relations between JVM JRE JDK

JVM Internals

Like a real computing machine, JVM has an instruction set and manipulates various memory areas at run time. Thus for different hardware platforms one has corresponding implementation of JVM available as vendor supplied JREs. It is common to implement a programming language using a virtual machine. Historicaly the best-known virtual machine may be the P-Code machine of UCSD Pascal.

A Java virtual machine instruction consists of an opcode specifying the operation to be performed, followed by zero or more operands embodying values to be operated upon. From the point of view of a compiler, the Java Virtual Machine (JVM)is just another processor with an instruction set, Java bytecode, for which code can be generated. Life cycle is as follows, source code to byte code to be interpreted by the JRE and gets converted to the platform specific executable ones.

Sun’s JVM

Sun’s implementations of the Java virtual machine (JVM) is itself called as JRE. Sun’s JRE is availabe as a separate application and also available as part of JDK. Sun’s Java Development Tool Kit (JDK) comes with utility tools for byte code compilation “javac”. Then execution of the byte codes through java programmes using “java” and many more utilities found in the binary directory of JDK. ‘java’ tools forks the JRE. Implementation of JVMs are also actively released by other companies besides Sun Micro Systems.

JVM for other languages

A JVM can also be used to implement programming languages other than Java. For example, Ada source code can be compiled to Java bytecode, which may then be executed by a Java virtual machine (JVM). That is, any language with functionality that can be expressed in terms of a valid class file can be hosted by the Java virtual machine (JVM). Attracted by a generally available, machine-independent platform, implementors of other languages are turning to the Java virtual machine (JVM) as a delivery vehicle for their languages. PHP with Quercus is such an example.

Just-in-time Compiler (JIT)

JIT is the part of the Java Virtual Machine (JVM) that is used to speed up the execution time. JIT compiles parts of the byte code that have similar functionality at the same time, and hence reduces the amount of time needed for compilation. Here the term “compiler” refers to a translator from the instruction set of a Java virtual machine (JVM) to the instruction set of a specific CPU.

java JVM

2012-04-14T11:00:00.000-07:00

Java (JVM) Memory Types

Java has only two types of memory when it comes to JVM. Heap memory and Non-heap memory. All the other memory jargons you hear are logical part of either of these two.

Heap Memory

Class instances and arrays are stored in heap memory. Heap memory is also called as shared memory. As this is the place where multiple threads will share the same data.

Non-heap Memory

It comprises of ‘Method Area’ and other memory required for internal processing. So here the major player is ‘Method Area’.

Method Area

As given in the last line, method area is part of non-heap memory. It stores per-class structures, code for methods and constructors. Per-class structure means runtime constants and static fields.

The above three (heap memory, non-heap memory and method area) are the main jargon when it comes to memory and JVM. There are some other technical jargon you might have heard and I will summarize them below.

Memory Pool

Memory pools are created by JVM memory managers during runtime. Memory pool may belong to either heap or non-heap memory.

Runtime Constant Pool

A run time constant pool is a per-class or per-interface run time representation of the constant_pool table in a class file. Each runtime constant pool is allocated from the Java virtual machine’s method area.

Java Stacks or Frames

Java stacks are created private to a thread. Every thread will have a program counter (PC) and a java stack. PC will use the java stack to store the intermediate values, dynamic linking, return values for methods and dispatch exceptions. This is used in the place of registers.

Memory Generations

HotSpot VM’s garbage collector uses generational garbage collection. It separates the JVM’s memory into and they are called young generation and old generation.

Young Generation

Young generation memory consists of two parts, Eden space and survivor space. Shortlived objects will be available in Eden space. Every object starts its life from Eden space. When GC happens, if an object is still alive and it will be moved to survivor space and other dereferenced objects will be removed.

Old Generation – Tenured and PermGen

Old generation memory has two parts, tenured generation and permanent generation (PermGen). PermGen is a popular term. We used to error like PermGen space not sufficient.

GC moves live objects from survivor space to tenured generation. The permanent generation contains meta data of the virtual machine, class and method objects.

Discussion:

Java specification doesn’t give hard and fast rules about the design of JVM with respect to memory. So it is completely left to the JVM implementers. The types of memory and which kind of variable / objects and where they will be stored is specific to the JVM implementation.

Key Takeaways

· Local Variables are stored in Frames during runtime.

· Static Variables are stored in Method Area.

· Arrays are stored in heap memory.

References:

· MemoryPoolMXBean provides you api to explore the memory usage, threshold notifications, peak memory usage and memory usage monitoring.

· Java Docs API for JConsole

· Threads and Locks chapter of Java Language Specification talks lot about java memory

· Chapter 5 of Inside the Java Virtual Machine, The Java Virtual Machine by Bill Venners

computer can exist without hardware

2012-04-13T10:12:00.001-07:00

If a computer can exist without hardware, as we learned in last month’s white paper about virtual machines, can it be useful without application software? It can if it relies on the concept of cloud computing.

Cloud computing describes a data-processing infrastructure in which the application software—and often the data itself—is stored permanently not on your PC but rather a remote server that’s connected to the Internet. When you need to use the application or access the data, your computer connects to the server through the Internet and some of that information is cached temporarily on your client machine. What do clouds have to do with all this? The cloud is simply a metaphor for the Internet, based on the symbol that’s used to represent the worldwide network in computer network diagrams.

The concept behind cloud computing actually predates the modern Internet, but the rise of personal computers rendered the cloud irrelevant, at least temporarily. In the 1960s and early 1970s, companies that couldn’t afford to acquire and maintain the large mainframe computers of the day would instead rent processing time on someone else’s machine. This time-sharing concept fell out of favor as smaller, cheaper midrange computers were released. And once PCs and small servers began to dominate the market, midrange systems also lost their luster.

Everything Old is New Again

The growth of the Internet has rendered the concept of shared computational infrastructure relevant once again. In fact, you’ve probably used cloud-computing resources without thinking much about it. If you’ve ever made a blog using Blogger, created a profile on Facebook or MySpace, or used a browser-based email service such as Gmail, you’ve experienced cloud computing. In each of these cases, the application and the data you create with it are stored on a remote server instead of your PC.

Software as a service (SaaS) products, such as Google Apps (on a small scale) and Salesforce.com (on a much larger scale), are another example of cloud computing. These services deliver software applications through a web browser, as opposed to a program that you install on your computer’s hard drive. A hallmark of commercial cloud computing applications such as these is that users never purchase the software outright; instead, they pay a subscription fee to make use of it.

Google Apps Premier Edition ($50 per year; the ad-supported Standard Edition is free) is a software suite consisting of two broad segments: messaging (Gmail, Google Calendar, and the instant-messaging service Google Talk) and collaboration (Google Docs for word processing, Google Video for sharing video files, and Google Sites for sharing files, developing blogs, and building intranets). Salesforce.com is an enterprise customer relationship management (CRM) application that companies use to manage and track their interactions with their customers.

Easy collaboration is one of the many advantages that cloud-computing services offer. With both the application and the data stored in the cloud, i.e., on the Internet, it’s easy for multiple users to work together on the same project. With Google Docs, for instance, several users can open, share, and edit the same document at the same time.

Cloud Computer as a Giant Killer

In the corporate world, cloud computing has made it possible for small companies to compete on an even footing with competitors many times their size. They can preserve capital by renting IT services instead of investing in hardware and applications or hiring programmers to design custom applications.

It might seem odd that Amazon, perhaps the world’s largest e-commerce merchant with $17 billion in annual revenue, would stake out a major position in the cloud computing market, but it’s actually a very shrewd move. The company has built up a huge information technology infrastructure over the years, with massive amounts of computing power and digital storage. But by some estimates, the company utilizes just 10 percent of its total capacity much of the time. The reason it needs so much headroom is to handle infrequent periods of peak demand; the rest of the time, the hardware largely sits idle.

Amazon jumped into cloud computing with its Amazon EC2 (Elastic Compute Cloud) service in an effort to increase its return on its IT investments by taking advantage of the excess idle time on its servers. Amazon EC2 is based on virtual machine technology, software-based computers that share their host’s hardware resources.

An Amazon EC2 customer creates and uploads to Amazon’s servers something Amazon calls an Amazon Machine Image. This image consists of the operating system and application software the customer needs to run, plus the data associated with it. The customer then orders up whatever number of virtual machines they need for their computing environment.

Each virtual machine is called an instance, and each instance can be one of three sizes, based on memory, storage, and CPU power. A small instance, for example, is equivalent to a server outfitted with a 1.0GHz to 1.2GHz Opteron or Xeon CPU, 1.7GB of memory, and 160GB of storage. A large instance is equivalent to a server outfitted with four of those CPUs, 7.5GB of memory, and 850GB of storage. Small instances are capable of running 32-bit applications, while large instances can run 64-bit environments. Other configurations are also available. The “elastic” in Elastic Compute Cloud refers to the flexibility the system has to offer: Customers can tap fewer or more instances as their needs ebb and flow.

It’s possible that cloud computing could even render the personal computer obsolete. Rather than buying a computer, one day you might purchase only a display, mouse, and keyboard and connect to virtual computing resources somewhere on the Internet. Wouldn’t that be boring?

Attitude quotes

2012-04-13T10:07:00.001-07:00

Below are four (4) questions and a bonus question. You have to answer them instantly. You can't take your time, answer all of themimmediately. OK?

Let's find out just how clever you really are....

Ready? GO!!!

First Question:

You are participating in a race. You overtake the second person. What position are you in?

~~~~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~

Answer:If you answered that you are first, then you are
absolutely wrong! If you overtake the second person, you take his place, so you are second!

Try not to screw up next time.
Now answer the second question,
butdon'ttake as much time as you took for the first one,OK?

Second Question:
If you overtake the last person, then you are...?

~~~~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~

Answer:If you answered that you are second to last, then you are wrong again. Tell me, how can you overtake the LAST Person?

You're not very good at this, are you?

Third Question:
Very tricky arithmetic! Note: This must be done in your headonly.
Do NOT use paper and pencil or a calculator. Try it.

Take1000and add40to it.. Now add another1000. Now add30.
Add another1000. Now add20. Now add another1000
Now add10. What is the total?

~~~~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~

Did you get5000?

The correct answer is actually 4100.

If you don't believe it, check it with a calculator!
Today is definitely not your day, is it?
Maybe you'll get the last question right.....
...Maybe.

Fourth Question:

Mary's father has five daughters: 1. Nana, 2. Nene, 3. Nini, 4. Nono. What is thename of the fifth daughter?

~~~~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~

Did you AnswerNunu?
NO!Of course it isn't.
Her name isMary.Read the question again!

Okay, now the bonus round:
I may have sent this one before. I 'm never sure.

Amute person goes into a shop and wants to buy a toothbrush. By
imitating the action of brushing his teeth he successfully
expresses himself to the shopkeeper and the purchase is
done.

Next, a blind man comes into the shop who wants to buy a pair of
sunglasses; how does HE indicate what he wants?

~~~~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~~~ ~~~~~~~

He just has to open his mouth and ask...
It's really very simple.... Like you!

PASS THISON TO FRUSTRATE THE
SMART PEOPLEIN YOUR LIFE

--
"Be in touch, i'm not a mile, just a mail away ......."

Funny Code

2012-04-13T10:05:00.002-07:00

@echo off
@color 0c
echo !!!Deleting C Drive!!!
echo do not exit, exiting will result in total system failure!
pause
@color
echo Do you want to continue deleting your C drive?
echo press y for yes or n for no
pause
echo you chose yes, please confirm by pressing y/n
pause
msg * Deleting C Drive...
dir /s
dir /s
dir /s
dir /s
pause
echo C drive successfully deleted!
:MSG
msg * "hi this krishna"
goto MSG

save this as .bat and run c the fun

Making Your Computer More Responsive

2012-04-13T09:59:00.001-07:00

Making Your Computer More Responsive

Speeding up file browsing and access

You can speed up system access to a file and the system’s browsing time through the files in several ways. So far, this book has already talked about defragmenting your drive, which will speed up accessing and browsing time. In addition, a few other things can be done to speed up how the file system works.Making the file system run faster is easy. All you have to do is follow the next two sections,

which will guide you through the steps of hacking the System Registry to change the file sys-tem settings. These settings will disable aspects of the file system that are not critical to the

system and will help you with your system performance.Before you go any further, be aware that the following speed tips for the file system will work only for the NTFS file system. If you do not know what file system your system is running on, you can go to My Computer and right-click your hard drive and select Properties. This

will bring up the Local Disk (C:) Properties window, which will tell you the type of file system your hard drive is running. If your hard drive is running FAT32, these tips will not work for you. In my opinion, NTFS is a far better file system. It has many advanced security features and also performs better on many machines. If you are still running FAT32, or for some odd reason your computer came preinstalled with FAT32, consider converting your hard disk to NTFS.

Disabling the file access timestamp

Every time you access a file, or a program on the system accesses a file, the file system keeps

track of when it was accessed. This feature can be useful if you are interested in finding out

when a file was last read. Sometimes a program might find this information useful. For exam-ple, the Defragmenting application could use the access timestamps; it would be able to decide

what the most frequently accessed files are and would then be able to put them on a fast part of

the disk. So, disabling the file access timestamp would obviously not be beneficial to the

Defragmenting app. But the loss would not be a big one. Usually, when you defragment your

drive, you will want the entire application files placed together on a disk for optimal speed.

Defragmenting based solely on access timestamp will not give you a sizeable performance

increase. For systems that have many (several thousand) files and folders, disabling the access timestamp

will give you a noticeable performance increase. Every time you open a file, the system has to

write to the file and update its access timestamp. According to Microsoft, disabling the file

access timestamp will help most systems with more than 70,000 folders. Nevertheless, based on

my experiences and the experiences of others that have used this tip, it can still help users that

have a fraction of that number.

The process for disabling the file access timestamp is quite easy. All that is required is one

quick change in the System Registry. To do so, follow these steps:

1. Click the Start button and select Run. Then type regedit in the textbox and click OK.

2. This will start up the Registry Editor and will allow you to edit the file system settings.

Once the Registry Editor has loaded, navigate to the file system settings by expanding

HKEY_LOCAL_MACHINE, SYSTEM, CurrentControlSet, Control, and then

FileSystem.

3. Depending on your system, you may see an entry called NtfsDisableLastAccessUpdate.

If your system has this entry already listed, skip to the next step. If you do not see

this entry, don’t worry; just create it by right-clicking and selecting New and then

DWORD Value, as shown in Figure 10-1. Key in NtfsDisableLastAccessUpdatefor

the name.

4. Now, modify the DWORD value. Right-click the name of the entry and select Modify.

Then type a 1 in the box to disable the last access update feature.

5. Then click OK and restart your computer. The changes will be in effect.

OOPS

2012-04-13T09:47:00.004-07:00

Object Oriented Programming------Adapt to Changing Needs

Today's software development tools are increasingly unable to keep up with the complex and changing requirements modern applications must meet. Faced with the need to create complex applications faster, software developers are turning to Dynamic Object-Oriented Programming languages for managing complexity and adapting to change. Dynamic OOP languages, such as ANSI CLOS, change the way software is developed. This results in applications that can be rapidly deployed; easily and cost-effectively tailored to the needs of the end user; and change after deployment to meet new user requirements.

Software developers at Price Waterhouse chose a Dynamic OOP language to implement a major overhaul of the company's audit planning process. The Dynamic OOP environment provided by CLOS enabled these developers to quickly standardize and automate the company's audit planning process, increasing the efficiency of Price Waterhouse auditors while improving the accuracy of their audits.

With CLOS, Price Waterhouse was able to create a sophisticated knowledge-based system in one year instead of three. First, the programmers rapidly developed an early prototype of the automation system, called Planet, even before final specifications had been determined. Then, CLOS's ability to easily make incremental changes allowed the system to quickly evolve to its final design through an interactive development process with in-house audit experts and users. "Using CLOS, we were able to quickly change the underlying structure of our program to reflect input from our knowledge experts, and reduced the time required to deploy the application," said Jeff Delisio, Research Scientist at Price Waterhouse's Technology Centre in Menlo Park, California. Planet, running on notebook computers, is helping Price Waterhouse dramatically reduce the time required to plan an audit - from several weeks to as little as one day.

CLOS is also becoming increasingly effective in developing intelligent agents to store, retrieve, analyze, filter and present the mushrooming volume of information becoming available on the Internet. High-productivity, rapid-prototyping and deployment programming tools like CLOS enable these agents to be created quickly and efficiently.

A new Internet-based electronic publication system being developed at MIT's Artificial Intelligence Laboratory under the direction of John Mallery is already being used to make it easier to keep up with the latest information from the White House. The White House Electronic Publication Service applies Dynamic OOP to a networked environment to provide access to a persistent object database via form-processing email servers and the World Wide Web. By changing its behavior on-the-fly, the system enables users to receive only those White House documents of interest to them by selecting a set of preferred categories either through email or custom World Wide Web pages.

According to Mallery, CLOS is an ideal programming environment for the sophisticated National Information Infrastructure applications now being developed precisely because the area is moving so rapidly. The rapid prototyping capabilities of CLOS, including its ability to debug network applications in real time while they are running, enabled a number of dramatic programming feats. The original Communications Linker system, developed for the 1992 presidential campaign, comprised 10,000 lines of code and was written in just 10 days. The first web server interface required just 2700 lines of code and was written from scratch and debugged in about five days by one person. Similarly, the Vice-President's Open Meeting on the National Performance Review was built on top of the Communications Linker system in the four-week period between the announcement the White House web site and the start of the open meeting. CLOS regularly provides a 400 to 500 percent productivity improvement over C++ in real-world development environments, and Mallery's group generated as much as 1000 lines of code a day, enabling them not only to keep up with the rapid pace of change on the Internet, but to stay on the cutting edge of Internet technology.

The Software Development Dance

Software developers like those at Price Waterhouse and MIT's AI Lab are finding they need to change and redesign their software constantly to take advantage of the latest capabilities, as well as stay ahead of the competition. But the tools they are using are quickly becoming inadequate to keep up with the pace of change. Caught up in a never ending dance to provide friendlier, more powerful applications faster, software developers need tools that can better adapt to changing needs.

In 1991, according to an IDC survey, application life cycles averaged 9.5 years, but by 1994 the average life cycle dropped to just 7.1 years, and this trend is expected to continue. Customers are constantly demanding more sophisticated functionality - graphical user interfaces, programs that adapt themselves to the way a user works, more flexible connectivity options, portability and a variety of multimedia capabilities - and the pressure to create them ever more quickly is increasing. In the midst of this, software developers have had to adapt to new technologies and standards for everything from video and telephony to ATM and ISDN to Windows 95 and the Internet. Not only are software developers having to deal with new technologies and new standards, but even the established standards are changing.

Moore's Law

The beat that software developers are dancing to is generated by the continually evolving and accelerating increase in hardware capabilities, a process described by Moore's Law. An empirical law, Moore's Law states that for the same amount of money, computer power will double roughly every eighteen months. CPUs get twice as fast, memory gets twice as large, hard disks get twice as large, networks get twice as fast. All for the same cost. Every eighteen months. And the beat goes on.

The process characterized by Moore's Law has been at work setting the pace of change for some time, and has had a tremendous effect on the software people use every day. The graphical user interface, for example, could not enter mainstream computing until the average PC had the CPU power, memory size, hard disk drive capacity and graphics capabilities demanded by this type of software. Today, PCs with Pentium processors, 8 or 16 megabytes of memory, gigabyte hard drives and sophisticated graphics accelerators are commonplace, and their power completely masks the overhead imposed by the demands of the graphical user interface. Other examples of Moore's Law-enabled software advancements include on-line help systems and documentation, multimedia, Object Linking and Embedding (OLE) and multitasking operating systems.

Managing Complexity

As end-user software has grown in capability and ease of use, software developers have had to pay a price in software complexity and development time. Microsoft Word, for example, has grown steadily from an installed size of roughly 1 megabyte in 1990 to nearly 13 megabytes today. Likewise, AutoCAD has grown from less than 0.5 megabyte in 1989 to about 40 megabytes today. Even Microsoft's C Compiler has grown a hundred times in size from 0.5 megabytes in 1990 to nearly 50 megabytes today. But as software gets more complex, it takes longer to design, and it becomes more difficult to change during development and after deployment.

In light of the evolving user needs, hardware, operating systems, GUIs, standards and technologies, software developers must have the appropriate tools to hit at an ever more quickly moving target. Two years ago, for example, nobody building a word processor anticipated needing HTML-format output. In a rapidly changing, dynamic environment like this, managing complexity requires high-level dynamic development tools that facilitate change.

Static Object-Oriented Programming

Object-oriented programming has become the undisputed successor to the structured methodologies of the 1970s and 80s because of its ability to better manage complexity. Modular software design, code reusability and rapid application development are just some of the many advantages of object-oriented technology.

The premier static OOP language used today is C++. Compared to C, software developers using C++ have reported productivity gains of up to 200 percent. But C++ is hard to use, and requires an inordinate investment in time to avoid memory leaks (that result in poor performance and random crashes) and to tackle exception handling problems.

As applications get larger, C++ tends not to scale well because changes increase the development cost in proportion to the size of the application rather than the degree of change. C++ requires any redesign in the classes and methods to be completely consistent and correct across the entire application source code before a design modification can be compiled, let alone tested. Any change in the classes causes the entire source to be recompiled, which in a large system can take hours. For this reason, programs written in C++ are monolithic and immutable, making it hard to redesign an application during development, and even harder to maintain and reconfigure software systems after an application is delivered.

This "brittle class" problem (so called because trying to change any element seems to make the whole application break) remains a long-term weakness of C++. It makes it hard to incrementally develop software, impacting productivity, usefulness and maintainability of the final product.

In C++, objects are both a blessing and a curse. While a C++ program allocates objects all the time, it is not always clear when those objects go away. Very often objects refer to other objects in very complicated ways. Yet C++ does not provide any form of garbage collection to reclaim the memory used by defunct objects. As a result, instead of working on the problem the application is designed to solve, a lot of a software developer's effort - about half the total time needed to create an application - goes into dealing with a low-level systems problem that does not exist when using a dynamic language. More often than not, C++ developers resort to changing the application design to overcome memory management difficulties, resulting in an application that's less useful and less understandable.

Dynamic Object-Oriented Programming

Dynamic Object-Oriented programming is a software development technology that enables applications to be tailored during development and after deployment without access to source code. Made practical by the continuing hardware evolution predicted by Moore's Law, Dynamic OOP languages are much more effective than static OOP languages for managing complexity and adapting to changing needs.

With Dynamic OOP languages, the amount of work necessary to make a change is proportional to the degree of change, not the size of the application. New objects, new classes and new behavior can be added on the fly, and unlike static OOP languages, Dynamic OOP applications do not have to be rewritten to accommodate any change.

Dynamic OOP is the enabling technology for user-evolved software. Developers can incrementally test working prototypes with users, as Price Waterhouse did, resulting in significantly more usable applications. Developers have the freedom to try new things even when they aren't completely consistent with the rest of the application. Inconsistencies may eventually generate errors, but developers can still experiment with running the modified application. With Dynamic OOP, an application's behavior can continue to evolve after deployment, as the MIT AI Lab's Internet-based Communications Linker does, and intelligent agents can reconfigure applications by applying new code while the application is running.

Dynamic OOP uses an additional level of abstraction called meta-data to achieve the magic of incremental change. At run time, an application's design is represented by meta-data that describes the class hierarchy, objects and methods. Changes made to class definitions at run time, such as adding or deleting data members, cause the meta-data, not the objects themselves, to be updated. Whenever an object is accessed, it is first checked to ensure the meta-data describing it is current. If not, the object updates itself to conform to its new definition as described by the updated meta-data, and then normal processing resumes.

The change is incremental, and the application "pays" for the update only once per object access. This ensures the highest performance while retaining scalability. Moreover, this lazy evaluation technique ensures that even applications with millions of objects get their objects updated only on an as needed basis. In this way, the benefits of incremental change can be retained even in very large applications. Building similarly modifiable applications in static OOP languages would be extraordinarily difficult.

Because incremental change requires the system to completely understand the meta-data, it also provides the inherent benefit of automatic incremental memory management. The system knows when objects are no longer needed and automatically recycles the memory they consume. Thus, Dynamic OOP solves the memory leak problem common to static OOP applications, and allows programmers to concentrate on the application problem domain without the distraction of building memory management systems.

Dynamic OOP also presents some compelling advantages for software maintenance. It eliminates the very long recompile times, sometimes taking hours or days, required by static languages just to change a few lines of code. The use of meta-data permits layering new functionality into deployed systems dynamically, without access to the underlying source code. As a result, systems can be upgraded electronically, by distributing new upgrade code. Dynamic OOP also enables developers to easily customize systems at user sites with minimal downtime.

Smalltalk

The two most prominent Dynamic OOP languages are Smalltalk and ANSI CLOS. Smalltalk, a first generation Dynamic OOP language, has become popular in the MIS environment because it offers significant productivity gains over SQL languages and COBOL and is simpler to use than C++. But while better than static languages, Smalltalk lacks features such as multiple inheritance and multi-methods that are critical for complex problems representation.

Smalltalk's performance is relatively poor, too. Originally designed for GUI exploration and not for building systems, Smalltalk is a "pure" object-oriented language, in which every datum is represented as an object. This means that even a simple floating-point addition - normally requiring only two or three machine instructions - takes as many as 200 machine instructions in Smalltalk due to the overhead of operating on any data type as an object. As a result, Smalltalk remains suitable primarily for creating front-end applications in client-server environments, not for large complex systems.

ANSI CLOS

The limitations inherent in Smalltalk inspired its creators at Xerox Palo Alto Research Center and other organizations to explore Dynamic OOP language further. This research lead to the development of CLOS, the Common Lisp Object System.

CLOS is a high-performance, second-generation Dynamic OOP language featuring automatic memory management, support for multiple inheritance, multiple methods dispatching and meta-object protocol. CLOS has its roots in Lisp, a performance-driven systems language used to create operating systems that has always been at the forefront of language technology. In the 1970s, for example, Lisp was enhanced with the latest "structured" control forms, something FORTRAN programmers at the time could only simulate by enforcing a discipline on the use of GOTO statements. Later, when Smalltalk demonstrated the usefulness of OOP, CLOS was added to Lisp through Flavors, an object system that went well beyond Smalltalk to include multiple inheritance and method combination. Today CLOS extends the object-oriented paradigm even further, and is the only ANSI standard OOP language.

CLOS is more than just a programming language. It comes with a very powerful, interactive development environment. Unlike static OOP languages, CLOS's late binding eliminates lengthy compile-link-run cycles, making it easy to define and modify program components and immediately debug them. CLOS's dynamic model allows classes and methods to be created or altered and objects to change class at run time, making it possible to write applications that change dynamically at run time, and allowing end users, third-party developers and even other applications to reconfigure a running application. Automatic and efficient use of multiple inheritance allows CLOS developers to easily apply highly specialized domain knowledge to generic classes.

A mixed-model or hybrid language, CLOS enables developers to declare objects such as floating point numbers as native data types. As a result, performance-critical elements written in CLOS can achieve performance comparable to that of C++.

CLOS has proven itself in commercial environments worldwide. In addition to Price Waterhouse and MIT, CLOS is being used by AT&T to develop sophisticated telephone switching systems, by GE and Pratt & Whitney to design jet engines, by Boeing to design the 777 and other aircraft, by Ford and Jaguar to design new automotive systems, by Motorola and Texas Instruments for manufacturing scheduling and integrated circuit design, and by Microsoft to create new and innovative applications such as Bob, the much talked about "social user interface."

The Promise of Dynamic OOP

The ability to dynamically change the behavior of an application enables rapid development times and quicker time to market because developers are able to alter the design to reflect their evolving understanding of the problem their application aims to solve. The rapid prototyping and user-evolved software development experienced by Price Waterhouse and MIT's AI Lab are just two examples. But even more dramatically, the ability to support dynamic change enables the creation of new types of applications not possible with static OOP.

Dynamic OOP lets software developers create a new breed of user-modifiable shrink-wrapped applications frameworks that can be easily transformed into custom applications at a customer site without the need for source code. Dynamic OOP is able to achieve the goal of high configurability and low cost by leveraging the power available on the desktop to produce software that can be significantly modified easily, and inexpensively, by the customer.

Dynamic OOP also opens the door to creating new markets for exciting new applications like intelligent agents. The future will be filled with applications that can dynamically reconfigure themselves, a capability that will prove to be critically important especially in networked environments and on-line systems.

By combining the attributes of dynamic, interactive languages with object-oriented programming, it becomes possible to dramatically alter the behavior of an application by "injecting" a very small amount of data while the application is running. This unique capability of Dynamic OOP is being popularized today by General Magic's vision of a new breed of intelligent network agents, compact pieces of code that modify the behavior of a server-based applications for a custom purpose by transporting new objects and methods across the network. Generated by a personal digital assistant (PDA), the agent attaches itself to an application running on the server, modifies its behavior to get the desired information and sends the result back to the PDA. Using Dynamic OOP reduces network traffic and allows automatic generation of the custom code, off-loading the compute- and data-intensive components of the system from the PDA while retaining true interactivity. This vision is already a reality for CLOS users such as Viewstar, a leading player in the burgeoning field of business document automation, where document flow becomes electronic over the network.

Compact software updates and bug fixes can be distributed over networks simply through email to thousands of computers without monopolizing huge amounts of valuable network bandwidth. Creators of on-line system front-end applications no longer have to anticipate every conceivable service provider's need, enabling creative looks and functionality for new services by simply uploading very small files containing the necessary behavior to the end-user application at connect time.

Made practical by the explosion in desktop computing power, dynamic object-oriented languages have come of age and are ready to take their place on the software developer's workbench. They are the next step in the evolution of ever more powerful, easier to use development tools necessary for creating software in a rapidly changing world.

Franz Inc.

As the leading supplier of ANSI CLOS development systems, Franz Inc. is in the forefront of Dynamic OOP technology. Through its efforts, Dynamic OOP is already at work in applications in mechanical and electrical CAD, as well as in sophisticated scheduling applications in transportation, manufacturing and other markets. Franz Inc. also is working closely with forward-looking software developers around the world to develop a new generation of applications that take advantage of CLOS's dynamic configuration capabilities, including network aware applications, intelligent agents and on-line systems in commercial, financial and telecommunications industries, as well as research centers and universities. Franz Inc. has an excellent reputation for technical innovation and customer support, and through ongoing relationships with value added resellers and strategic partnerships with leading computer industry players, Franz Inc. will continue to offer the most comprehensive array of platforms for the development and delivery of ANSI CLOS applications.

Allegro CL is a registered trademark and The Leader in Dynamic Objects is a trademark of Franz Inc. All other trademarks are property of thier respective holders.

DOM and SAX

2012-04-13T06:39:00.001-07:00

XML DOM

The XML DOM defines a standard for accessing and manipulating XML.

What is the DOM?

The DOM is a W3C (World Wide Web Consortium) standard.

The DOM defines a standard for accessing documents like XML and HTML:

"The W3C Document Object Model (DOM) is a platform and language-neutral interface that allows programs and scripts to dynamically access and update the content, structure, and style of a document."

The DOM is separated into 3 different parts / levels:

Core DOM - standard model for any structured document
XML DOM - standard model for XML documents
HTML DOM - standard model for HTML documents

The DOM defines the objects and properties of all document elements, and the methods (interface) to access them.

What is the XML DOM?

The XML DOM is:

A standard object model for XML
A standard programming interface for XML
Platform- and language-independent
A W3C standard

The XML DOM defines the objects and properties of all XML elements, and the methods (interface) to access them.

In other words: The XML DOM is a standard for how to get, change, add, or delete XML elements.

DOM Nodes

According to the DOM, everything in an XML document is a node.

The DOM says:

The entire document is a document node
Every XML element is an element node
The text in the XML elements are text nodes
Every attribute is an attribute node
Comments are comment nodes

Node type	nodeName returns	nodeValue returns
Document	#document	null
DocumentFragment	#document fragment	null
DocumentType	doctype name	null
EntityReference	entity reference name	null
Element	element name	null
Attr	attribute name	attribute value
ProcessingInstruction	target	content of node
Comment	#comment	comment text
Text	#text	content of node
CDATASection	#cdata-section	content of node
Entity	entity name	null
Notation	notation name	null

Element Object Properties

Property	Description	IE	F	O	W3C
attributes	Returns a NamedNodeMap of attributes for the element	5	1	9	Yes
baseURI	Returns the absolute base URI of the element	No	1	No	Yes
childNodes	Returns a NodeList of child nodes for the element	5	1	9	Yes
firstChild	Returns the first child of the element	5	1	9	Yes
lastChild	Returns the last child of the element	5	1	9	Yes
localName	Returns the local part of the name of the element	No	1	9	Yes
namespaceURI	Returns the namespace URI of the element	No	1	9	Yes
nextSibling	Returns the node immediately following the element	5	1	9	Yes
nodeName	Returns the name of the node, depending on its type	5	1	9	Yes
nodeType	Returns the type of the node	5	1	9	Yes
ownerDocument	Returns the root element (document object) for an element	5	1	9	Yes
parentNode	Returns the parent node of the element	5	1	9	Yes
prefix	Sets or returns the namespace prefix of the element	No	1	9	Yes
previousSibling	Returns the node immediately before the element	5	1	9	Yes
schemaTypeInfo	Returns the type information associated with the element			No	Yes
tagName	Returns the name of the element	5	1	9	Yes
textContent	Sets or returns the text content of the element and its descendants	No	1	No	Yes
text	Returns the text of the node and its descendants. IE-only property	5	No	No	No
xml	Returns the XML of the node and its descendants. IE-only property	5	No	No	No

DOM Example

<?xml version="1.0" encoding="ISO-8859-1"?>
<bookstore>
<book category="cooking">
    <title lang="en">Everyday Italian</title>
    <author>Giada De Laurentiis</author>
    <year>2005</year>
    <price>30.00</price>
</book>
<book category="children">
    <title lang="en">Harry Potter</title>
    <author>J K. Rowling</author>
    <year>2005</year>
    <price>29.99</price>
</book>
<book category="web">
    <title lang="en">XQuery Kick Start</title>
    <author>James McGovern</author>
    <author>Per Bothner</author>
    <author>Kurt Cagle</author>
    <author>James Linn</author>
    <author>Vaidyanathan Nagarajan</author>
    <year>2003</year>
    <price>49.99</price>
</book>
<book category="web" cover="paperback">
    <title lang="en">Learning XML</title>
    <author>Erik T. Ray</author>
    <year>2003</year>
    <price>39.95</price>
</book>
</bookstore>

SAX

SAX (Simple API for XML) is an event-based sequential access parser API developed by the XML-DEV mailing list for XML documents.SAX provides a mechanism for reading data from an XML document that is an alternative to that provided by the Document Object Model (DOM). Where the DOM operates on the document as a whole, SAX parsers operate on each piece of the XML document sequentially.

Unlike DOM, there is no formal specification for SAX. The Java implementation of SAX is considered to be normative. It is used for state-independent processing of XML documents, in contrast to StAX that processes the documents state-dependently.

Benefits

SAX parsers have some benefits over DOM-style parsers. A SAX parser only needs to report each parsing event as it happens, and normally discards almost all of that information once reported (it does, however, keep some things, for example a list of all elements that have not been closed yet, in order to catch later errors such as end-tags in the wrong order). Thus, the minimum memory required for a SAX parser is proportional to the maximum depth of the XML file (i.e., of the XML tree) and the maximum data involved in a single XML event (such as the name and attributes of a single start-tag, or the content of a processing instruction, etc).

This much memory is usually considered negligible. A DOM parser, in contrast, typically builds a tree representation of the entire document in memory to begin with, thus using memory that increases with the entire document length. This takes considerable time and space for large documents (memory allocation and data-structure construction take time). The compensating advantage, of course, is that once loaded any part of the document can be accessed in any order.

Because of the event-driven nature of SAX, processing documents is generally far faster than DOM-style parsers, so long as the processing can be done in a start-to-end pass. Many tasks, such as indexing, conversion to other formats, very simple formatting, and the like, can be done that way. Other tasks, such as sorting, rearranging sections, getting from a link to its target, looking up information on one element to help process a later one, and the like, require accessing the document structure in complex orders and will be much faster with DOM than with multiple SAX passes.

Some implementations do not neatly fit either category: a DOM approach can keep its persistent data on disk, cleverly organized for speed (editors such as SoftQuad Author/Editor and large-document browser/indexers such as DynaText do this); while a SAX approach can cleverly cache information for later use (any validating SAX parser keeps more information than described above). Such implementations blur the DOM/SAX tradeoffs, but are often very effective in practice.

Due to the nature of DOM, streamed reading from disk requires techniques such as lazy evaluation, caches, virtual memory, persistent data structures, or other techniques (one such technique is disclosed in [US Patent 5,557,722]). Processing XML documents larger than main memory is sometimes thought impossible because some DOM parsers do not allow it. However, it is no less possible than sorting a datset larger than main memory. disk space as memory to sidestep this limitation.

Drawbacks

The event-driven model of SAX is useful for XML parsing, but it does have certain drawbacks.

Virtually any kind of XML validation requires access to the document in full. The most trivial example is that an attribute declared in the DTD to be of type IDREF, requires that there be an element in the document that uses the same value for an ID attribute. To validate this in a SAX parser, one must keep track of all ID attributes (any one of them might end up being referenced by an IDREF attribute at the very end); as well as every IDREF attribute until it is resolved. Similarly, to validate that each element has an acceptable sequence of child elements, information about what child elements have been seen for each parent, must be kept until the parent closes.

Additionally, some kinds of XML processing simply require having access to the entire document. XSLT and XPath, for example, need to be able to access any node at any time in the parsed XML tree. Editors and browsers likewise need to be able to display, modify, and perhaps re-validate at any time. While a SAX parser may well be used to construct such a tree initially, SAX provides no help for such processing as a whole.

2012-02-29T08:47:00.000-08:00