My Thougths

Green Cleaning: Its impacts on Health & Environment

Tue, 08 May 2018 09:03:00 +0000

Green cleaning refers to the use of cleaning methods and products that are environmental friendly in nature as it contains ingredients and products that are designed to preserve and create no harm to the human health and environment quality.

These green cleaning products and techniques avoid the use of materials which contain toxic or harsh chemicals some of which emit volatile organic compounds which cause respiratory, dermatological and other dreaded conditions. Products are environmental friendly and biodegradable.

Little that we verify, what it is in that container of Your favorite Cleaning Product?

Experts say that most of the cleaning products are made up of enormous amount of chemicals which can impact the health of users. As people are being more aware of the impacts and zooming in the market, people begin rethinking what they will be bringing into their homes.

Famous water pollutant is phosphates, water-softening mineral additives that were once widely used in laundry detergents and other cleaners. When phosphates enter waterways, they act as a fertilizer, spawning overgrowth of algae. This overabundance of aquatic plant life eventually depletes the water's oxygen supply, killing off fish and other organisms.

Products that list active ingredients of Chlorine or Ammonia, which can cause respiratory and skin irritation and will create toxic fumes if accidentally mixed together.

The biggest impact of cleaning products comes from the chemical content which has not been tested for safety. These pollute streams and rivers and take a long time to disintegrate.

Safety Tip: Avoid cleaners marked "Danger" or "Poison" on the label, and look out for other tell-tale hazard warnings, such as "corrosive" or "may cause burns."

Reasons why we need switch to Green Cleaning products.

1. Healthier Homes – If one goes green, “No longer will there be chemicals absorbed into the skin or breathed in by the person cleaning,”. Family members would gain health benefits as they no longer breath in cleaners of harmful effects in the air and sitting on surfaces. Studies were also done and proved that continuous use of non-green cleaning spray even just once a week would raise risk of getting and developing Asthma. Traditional and non-green cleaning products pose risks such as chemical burns to any household owners’ skin and eyes.

2. Building Safe Environment – when you use many cleaning products, “harmful chemicals are being released into the environment.” Changing to greener methods and application of green cleaning tips will help reduce pollution to the waterways and the air and it also minimizes the impact on the ozone depletion and global climate change with fewer smog producing chemicals. Many green products also use recyclable packaging which minimizes waste.

3. Better Air quality at Home– Most people cannot stand the strong stench of chemical odours. Many green cleaning products including store bought and ones you can make at home emits pleasant natural essential oils.

4. Cheaper & Cost Effective – Many people think that Environment friendly products are costlier. Infect these products are cheaper because they don’t contain multiple chemicals. And to hide these Chemical Odours, additional Fragrances are not required.

"We have not inherited this earth from our ancestors but we have borrowed it from our children". I have heard this statement many a times, but I could only understand it when I was blessed with my Son. I am realizing it more every day that I am responsible for making this place better for my Son and their generation. I am sure you also feel the same.

Why not fill a Survey to tell your experience: Green Clearning Survey

So, What is E-commerce?

Mon, 29 Mar 2010 12:22:00 +0000

The Internet has created a new economic ecosystem, the e-commerce marketplace, and it has become the virtual main street of the world. Providing a quick and convenient way of exchanging goods and services both regionally and globally, e-commerce has boomed. Today, e-commerce has grown into a huge industry with US online retail generating $179 billion in revenues in 2010, with consumer-driven (B2C) online transactions impacting industries from travel services to consumer electronics, from books and media distribution to sports & fitness. So Lets see what is E-commerce:

E-commerce: E-commerce (electronic commerce or EC) is the buying and selling of goods and services on the Internet. In practice, this term and e-business are often used interchangeably. For online retail selling, the term e-tailing is sometimes used. It has lot of benefits too:
1. Global Presence: The penetration of your business is Global. Means your business can go from India to US, Australia to South Africa.
2. Less Cost: The cost of operations is affordable to anyone. Anyone with a good idea can start and e-commerce business without much investment and can get good returns.

Many people see e-commerce as some software or some website. These are the aids to perform the business over internet. For better understanding, you can see this link. How E-commerce Works

I hope this will help.

Capturing a Screenshot in Java (Using AWT)

Fri, 07 Nov 2008 12:21:00 +0000

Taking a screen shot in Java, sounds interesting right. Suddenly, While Searching to internet I came across this.

Here is the piece of code with which you can do this task:

import java.awt.AWTException;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class ScreenCapture {

public static void main(String[] args) {
try {
Robot robot = new Robot();

//The Size of Rectangle is Similar to Screen Resolution.
BufferedImage bi=robot.createScreenCapture(new Rectangle(1280,1024));

//This will write the image to this particular location
ImageIO.write(bi, "jpg", new File("C:/Ashish Docs/ScreenShot.jpg"));

} catch (AWTException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}catch(Exception ex){
ex.printStackTrace();
}
}
}

Don't worry guys the code is working and tested. Here is the same output of this program:

I hope this will help. Cheers.....

Ashish Mishra

"There are some people who live in a Dream World, And There are some who face Reality; And Then there are those who turn One into the Other "

Bridging Java and Adobe Air - Merapi

Thu, 16 Oct 2008 12:53:00 +0000

How Exiciting it will be if you can call Java directly from an AIR Application? I got excited when i read first time. And I feel you will also be. So why to wait, here is the solution for it........ Merapi
Merapi: A Bridge between Adobe AIR and Java
Merapi is a bridge between applications written in Java and those running in and created for Adobe AIR™ (Adobe Integrated Runtime™).

Merapi has been designed to run on a user's machine, along with an Adobe AIR™application and providea direct bridge between the Adobe AIR™ framework and Java, exposing the power and overall calabilities of the user's operating system, including 3rd party hardware devices.

With a light weight and straightforward API, developers can leverage the OS by writing Java companion applications for their AIR™ applications. Java programs treat Merapi as a bridge to the running Adobe AIR™ application and vice-versa. How to achieve this is given below:

Sending a message from ActionScript:

var message : Message = new Message();
message.data = "Hello from Merapi Flex.";
message.type = "Reply";
Bridge.instance.sendMessage( message );

Sending a message from Java:

Bridge bridge = Bridge.getInstance();
Message message = new Message();
message.setData("Hello from Merapi Java.");
bridge.sendMessage(message);

Receiving a message in Flex:

<merapi:BridgeInstance

id="bridge" result="handleResult(event)" />

in Script:

private function handleResult( event : ResultEvent ) : void{

var message : IMessage = event.result as IMessage;

}

Receiving a message in Java:

Bridge.getInstance().registerMessageHandler("Reply", messageHandlerInstance );

public void handleMessage( IMessage message ){

System.out.println( message.getData() );

}

Finding Postions of HTML Element in a Scrollable Div

Fri, 25 Jul 2008 11:36:00 +0000

Hi Friends,

Have you ever find it difficult to find the x, y coordinates value for a HTML element in side a scrollable div. Just few days back, i got this problem. where i wanted to show tool tip on a link, but since the HTML element was in a scrollable div, the positioning to tooltip was not correct. Here is the code earlier i used to find the X and Y positions:

function findPosX(obj)
{
var curleft = 0;
if (obj.offsetParent)
{
while (obj.offsetParent)
{
curleft += obj.offsetLeft
obj = obj.offsetParent;
}
}
else if (obj.x)
curleft += obj.x;
return curleft;
}

function findPosY(obj)
{
var curtop = 0;
if (obj.offsetParent)
{
while (obj.offsetParent)
{
curtop += obj.offsetTop
obj = obj.offsetParent;
}
}
else if (obj.y)
curtop += obj.y;
return curtop;
}

This function works well when your HTML element is not within a scrollable div. But what if it is present inside a scrollable div? So here is the solutions. I found that we are using prototype.js. Which has a Element called Position. This helps to find out the actual pixel value for X and Y coordinate. Here is code how to calculate is:

var iebody = (document.compatMode && document.compatMode != "BackCompat")? document.documentElement : document.body;

var dsocleft = document.all? iebody.scrollLeft : pageXOffset;
var dsoctop = document.all? iebody.scrollTop : pageYOffset;

var posReal = Position.realOffset(obj);
//Position is a readymade object in prototype.js
var pos = Position.cumulativeOffset(obj);

var top = pos[1] - posReal[1] + dsoctop;
//value of Y
var left = pos[0] + posReal[1] - dsocleft;
//value of X

In this way, you can find the accurate pixel value of X and Y coordinates. I hope this will help you all.

Technorati Tags: Positions in Scrollable Div, JavaScript, Prototype.js,

Removing null or specific values from list in Java

Thu, 05 Jun 2008 12:45:00 +0000

Have you tried to remove null values from a List (may a ArrayList). Yesterday I was trying it out, when I had to remove null values from a List before processing it.

Initially, I was trying with the simple for loop and out I was getting Still NullPointerException while processing. I tried with couple of ways, before I came to a efficient one. Lets see this with an example:

Lets see what are the flaws, when u try to remove null values from a List with a for loop:

List li = new ArrayList();

FileListItem fLI = new FileListItem();

fLI.setFormFileName("123");

FileListItem fLI2 = new FileListItem();

FileListItem fLI3 = new FileListItem();

FileListItem fLI4 = new FileListItem();

fLI4.setFormFileName("456");

li.add(fLI);

li.add(fLI2);

li.add(fLI3);

li.add(fLI4);

System.out.println("====this.fileList() =====" + li);

for(int i = 0;i <>

System.out.println("li Size ====" + li.size() + " & Value of i ===== "+i);

FileListItem fileListItem = (FileListItem) li.get(i);

System.out.println("fileListItem is ====== "+fileListItem);

if(null == fileListItem.getFormFileName())

li.remove(i);

}

System.out.println("====this.fileList() =====" + li);

What output it will produce, Lets see

=== this.fileList()==[FileListItem{ formFileName=123}, FileListItem{ formFileName=null}, FileListItem{ formFileName=null}, FileListItem{ formFileName=456}]

li Size ====4 & Value of i ===== 0

fileListItem is ====== FileListItem{ formFileName=123}

li Size ====4 & Value of i ===== 1

fileListItem is ====== FileListItem{ formFileName=null}

li Size ====3 & Value of i ===== 2

fileListItem is ====== FileListItem{ formFileName=456}

=== this.fileList()== [FileListItem{ formFileName=123}, FileListItem{ formFileName=null}, FileListItem{ formFileName=456}]

Here it still contains a Null Value in it.

So what is the efficient way to remove elements from a list:

Iterator is wonderful thing to handle it. Lets see the same thing with Iterator.

System.out.println("====this.fileList() =====" + li);

Iterator itr = li.iterator();

while(itr.hasNext()){

FileListItem fileListItem = (FileListItem) itr.next();

if(null == fileListItem.getFormFileName())

itr.remove();

}

System.out.println("====this.fileList() =====" + li);

Here the Output will be :

====this.fileList() ===== [FileListItem{ formFileName=123}, FileListItem{ formFileName=null}, FileListItem{ formFileName=null}, FileListItem{ formFileName=456}]

====this.fileList() ===== [FileListItem{ formFileName=123}, FileListItem{ formFileName=456}]

ListIterator can also be used for the same, but ListIterator give you additional advantage of adding elements to a list, while iterating it.

Please download the complete code from here: ListDemoCode

Holi 2008 - Better than Expected

Wed, 26 Mar 2008 12:43:00 +0000

Hi Friends,

This time I celebrated holi in Pune. This year it was special. Check out the photos, which will tell you about it.

Thanks My frens, who were there with Me. I hope Everybody had a great fun on that day.

Its nothing but All about me.

Fri, 14 Mar 2008 09:46:00 +0000

Hi Friends,

I am Ashish Kumar Mishra. I am an Indian. I born an brought up in Hisar, a district of Haryana. I did my schooling from Hisar. But Schools keep changing after every year or 2. I did my Matriculation, From Leading High School. And Intermediate from New Yashoda Public School. Then I joined degree program from Maharshi Dayanand University in Computer Applications. In my school days (Before Matriculation), I decided that i am going for a Degree in Computers and I thought a Degree in Computer Applications was a better option.

After my graduation, I went to Delhi, started preparing for the Entrance of Post Graduation in Computer Application. I joined a Company in Delhi as Trainee Programmer. But my father wanted me to go for Higher Educations. Even I wanted to go for it. And I took admission in my Post Graduation Programme in Computer Application offered by Amravati University. I passed my Post Graduation in 2007. But in 5th Semester, I joined a Company called Vision System Group in Hyderabad. My previous experience was helping me to grow up as a Computer Professional. I was not as novice as my other colleagues joined with me. I was working on Java Technology, where i wanted to work.

Each day was a new learning. I was enjoying my each day on work. I completed my 1 year there. Then something unwanted happened. The company was going to Split.

It was time to search for another opportunity. And I Joined QuinStreet in the Month
of January 2008. And Again I am working on Java technology Here.

In QuinStreet, it just few days, but i feel i have been working here from many year. Colleagues becomes friends. Working here is more fun here.

This is all about me- Ashish Kumar Mishra.

Sun To acquire MySQL

Thu, 17 Jan 2008 10:02:00 +0000

Sun Microsystems is going to jump in the database market with the purchase of most successful open source database developer MySQL for $1 billion. This is the main center of attraction on both the websites:

&

With the move, announced Wednesday, Sun takes a big leap into the $15 billion database market and pits it against the likes of Microsoft, IBM and Oracle. MySQL have clients Facebook, Google, Nokia and Baidu as customers.

What makes MySQL interesting to Sun. About 20 percent of MySQL deployments run on Solaris, according to Sun estimates outlined on a conference call. Seventy five percent of MySQL deployments are not on Sun hardware. That gives Sun an opportunity to bundle hardware software and services.

While Sun can also distribute MySQL through its channel and OEM partnerships and create various bundles. The overarching goal is to give MySQL more “commercial appeal” and boost adoption of open source software in the enterprise.

One big question is what Sun does next to build out its stack of open source software and other applications covering middleware, storage and virtualization. Sun’s software lineup now includes Java, MySQL, OpenSolaris and GlassFish.

Sun plans to integrate MySQL into its software, sales and service groups and MySQL CEO Marten Mickos will stay after the acquisition.

Now many questions are evolving out in the IT market. Like

Is it a deal against the Microsoft to fight with Sql Server ?
How will MySQL community handle being part of Sun ?
Is it a beneficial to MySql future or it may loose its shine among Open Source world?

In near future we may expect a better J2EE Stack bundled with a better database in it. But definitely MySQL CEO, Marten Mickos, will be in cloud Nine at this time with this deal.

Three Rules for Effective Exception Handling

Thu, 03 Jan 2008 05:53:00 +0000

Exceptions in Java provide a consistent mechanism for identifying and responding to error conditions. Effective exception handling will make your programs more robust and easier to debug. Exceptions are a tremendous debugging aid because they help answer these three questions:

• What went wrong?
• Where did it go wrong?
• Why did it go wrong?

When exceptions are used effectively, what is answered by the type of exception thrown, where is answered by the exception stack trace, and why is answered by the exception message. If you find your exceptions aren't answering all three questions, chances are they aren't being used effectively. Three rules will help you make the best use of exceptions when debugging your programs.

These rules are: be specific, throw early, and catch late.

To illustrate these rules of effective exception handling, this article discusses a fictional personal finance manager called JCheckbook. JCheckbook can be used to record and track bank account activity, such as deposits, withdrawals, and checks written. The initial version of JCheckbook runs as a desktop application, but future plans call for an HTML client and a client/server applet implementation.

1. Be Specific
Java defines an exception class hierarchy, starting with Throwable, which is extended by Error and Exception, which is then extended by RuntimeException. These are illustrated in Figure 1.

Figure 1. Java exception hierarchy

These four classes are generic and they don't provide much information about what went wrong. While it is legal to instantiate any of these classes (e.g., new Throwable()), it is best to think of them as abstract base classes, and work with more specific subclasses. Java provides a substantial number of exception subclasses, and you may define your own exception classes for additional specificity.

For example, the java.io package defines the IOException subclass, which extends Exception. Even more specific are FileNotFoundException, EOFException, and ObjectStreamException, all subclasses of IOException. Each one describes a particular type of I/O-related failure: a missing file, an unexpected end-of-file, or a corrupted serialized object stream, respectively. The more specific the exception, the better our program answers what went wrong.

It is important to be specific when catching exceptions, as well. For example, JCheckbook may respond to a FileNotFoundException by asking the user for a different file name. In the case of an EOFException, it may be able to continue with just the information it was able to read before the exception was thrown. If an ObjectStreamException is thrown, the program may need to inform the user that the file has been corrupted, and that a backup or a different file needs to be used.

Java makes it fairly easy to be specific when catching exceptions because we can specify multiple catch blocks for a single try block, each handling a different type of exception in an appropriate manner.

File prefsFile = new File(prefsFilename);

try
{
readPreferences(prefsFile);
}
catch (FileNotFoundException e)
{
// alert the user that the specified file
// does not exist
}
catch (EOFException e)
{
// alert the user that the end of the file
// was reached
}
catch (ObjectStreamException e)
{
// alert the user that the file is corrupted
}
catch (IOException e)
{
// alert the user that some other I/O
// error occurred
}

JCheckbook uses multiple catch blocks in order to provide the user with specific information about the type of exception that was caught. For instance, if a FileNotFoundException was caught, it can instruct the user to specify a different file. The extra coding effort of multiple catch blocks may be an unnecessary burden in some cases, but in this example, it does help the program respond in a more user-friendly manner.

Should an IOException other than those specified by the first three catch blocks be thrown, the last catch block will handle it by presenting the user with a somewhat more generic error message. This way, the program can provide specific information when possible, but still handle the general case should an unanticipated file-related exception "slip by."

Sometimes, developers will catch a generic Exception and then display the exception class name or stack trace, in order to "be specific." Don't do this. Seeing java.io.EOFException or a stack trace printed to the screen is likely to confuse, rather than help, the user. Catch specific exceptions and provide the user with specific information in English (or some other human language). Do, however, include the exception stack trace in your log file. Exceptions and stack traces are meant as an aid to the developer, not to the end user.

Finally, notice that instead of catching the exception in the readPreferences() method, JCheckbook defers catching and handling the exception until it reaches the user interface level, where it can alert the user with a dialog box or in some other fashion. This is what is meant by "catch late," as will be discussed later in this article.

2. Throw Early

The exception stack trace helps pinpoint where an exception occurred by showing us the exact sequence of method calls that lead to the exception, along with the class name, method name, source code filename, and line number for each of these method calls. Consider the stack trace below:

java.lang.NullPointerException
at java.io.FileInputStream.open(Native Method)
at java.io.FileInputStream.(FileInputStream.java:103)
at jcheckbook.JCheckbook.readPreferences(JCheckbook.java:225)
at jcheckbook.JCheckbook.startup(JCheckbook.java:116)
at jcheckbook.JCheckbook.(JCheckbook.java:27)
at jcheckbook.JCheckbook.main(JCheckbook.java:318)

This shows that the open() method of the FileInputStream class threw a NullPointerException. But notice that FileInputStream.close() is part of the standard Java class library. It is much more likely that the problem that is causing the exception to be thrown is within our own code, rather than the Java API. So the problem must have occurred in one of the preceding methods, which fortunately are also displayed in the stack trace.

What is not so fortunate is that NullPointerException is one of the least informative (and most frequently encountered and frustrating) exceptions in Java. It doesn't tell us what we really want to know: exactly what is null. Also, we have to backtrack a few steps to find out where the error originated.

By stepping backwards through the stack trace and investigating our code, we determine that the error was caused by passing a null filename parameter to the readPreferences() method. Since readPreferences() knows it cannot proceed with a null filename, it checks for this condition immediately:

public void readPreferences(String filename)
throws IllegalArgumentException
{
if (filename == null)
{
throw new IllegalArgumentException
("filename is null");
} //if

//...perform other operations...

InputStream in = new FileInputStream(filename);

//...read the preferences file...
}

By throwing an exception early (also known as "failing fast"), the exception becomes both more specific and more accurate. The stack trace immediately shows what went wrong (an illegal argument value was supplied), why this is an error (null is not allowed for filename), and where the error occurred (early in the readPreferences() method). This keeps our stack trace honest:

java.lang.IllegalArgumentException: filename is null
at jcheckbook.JCheckbook.readPreferences(JCheckbook.java:207)
at jcheckbook.JCheckbook.startup(JCheckbook.java:116)
at jcheckbook.JCheckbook.(JCheckbook.java:27)
at jcheckbook.JCheckbook.main(JCheckbook.java:318)

In addition, the inclusion of an exception message ("filename is null") makes the exception more informative by answering specifically what was null, an answer we don't get from the NullPointerException thrown by the earlier version of our code.

Failing fast by throwing exceptions as soon as an error is detected can eliminate the need to construct objects or open resources, such as files or network connections, that won't be needed. The clean-up effort associated with opening these resources is also eliminated.

3. Catch Late
A common mistake of many Java developers, both new and experienced, is to catch an exception before the program can handle it in an appropriate manner. The Java compiler reinforces this behavior by insisting that checked exceptions either be caught or declared. The natural tendency is to immediately wrap the code in a try block and catch the exception to stop the compile from reporting errors.

The question is, what to do with an exception after it is caught? The absolute worst thing to do is nothing. An empty catch block swallows the exception, and all information about what, where, and why something went wrong is lost forever. Logging the exception is slightly better, since there is at least a record of the exception. But we can hardly expect that the user will read or even understand the log file and stack trace. It is not appropriate for readPreferences() to display a dialog with an error message, because while JCheckbook currently runs as a desktop application, we also plan to make it an HTML-based web application. In that case, displaying an error dialog is not an option. Also, in both the HTML and the client/server versions, the preferences would be read on the server, but the error needs to be displayed in the web browser or on the client. The readPreferences() method should be designed with these future needs in mind. Proper separation of user interface code from program logic increases the reusability of our code.

Catching an exception too early, before it can properly be handled, often leads to further errors and exceptions. For example, had the readPreferences() method shown earlier immediately caught and logged the FileNotFoundException that could be thrown while calling the
FileInputStream constructor, the code would look something like this:

public void readPreferences(String filename)
{
//...

InputStream in = null;

// DO NOT DO THIS!!!
try
{
in = new FileInputStream(filename);
}
catch (FileNotFoundException e)
{
logger.log(e);
}

in.read(...);

//...
}

This code catches FileNotFoundException, when it really cannot do anything to recover from the error. If the file is not found, the rest of the method certainly cannot read from the file. What would happen should readPreferences() be called with the name of file that doesn't exist? Sure, the FileNotFoundException would be logged, and if we happened to be looking at the log file at the time, we'd be aware of this. But what happens when the program tries to read data from the file? Since the file doesn't exist, in is null, and a NullPointerException gets thrown.

When debugging a program, instinct tells us to look at the latest information in the log. That's going to be the NullPointerException, dreaded because it is so unspecific. The stack trace lies, not only about what went wrong (the real error is a FileNotFoundException, not a NullPointerException), but also about where the error originated. The problem occurred several lines of code away from where the NullPointerException was thrown, and it could have easily been several method calls and classes removed. We end up wasting time chasing red herrings that distract our attention from the true source of the error. It is not until we scroll back in the log file that we see what actually caused the program to malfunction.

What should readPreferences() do instead of catching the exceptions? It may seem counterintuitive, but often the best approach is to simply let it go; don't catch the exception immediately. Leave that responsibility up to the code that calls readPreferences(). Let that code determine the appropriate way to handle a missing preferences file, which could mean prompting the user for another file, using default values, or, if no other approach works, alerting the user of the problem and exiting the application.

The way to pass responsibility for handling exceptions further up the call chain is to declare the exception in the throws clause of the method. When declaring which exceptions may be thrown, remember to be as specific as possible. This serves to document what types of exceptions a program calling your method should anticipate and be ready to handle. For example, the "catch late" version of the readPreferences() method would look like this:

public void readPreferences(String filename)
throws IllegalArgumentException,
FileNotFoundException, IOException
{
if (filename == null)
{
throw new IllegalArgumentException
("filename is null");
} //if

//...

InputStream in = new FileInputStream(filename);

//...
}

Technically, the only exception we need to declare is IOException, but we document our code by declaring that the method may specifically throw a FileNotFoundException. IllegalArgumentException need not be declared, because it is an unchecked exception (a subclass of RuntimeException). Still, including it serves to document our code (the exceptions should also be noted in the JavaDocs for the method).

Of course, eventually, your program needs to catch exceptions, or it may terminate unexpectedly. But the trick is to catch exceptions at the proper layer, where your program can either meaningfully recover from the exception and continue without causing further errors, or provide the user with specific information, including instructions on how to recover from the error. When it is not practical for a method to do either of these, simply let the exception go so it can be caught later on and handled at the appropriate level.

Conclusion
Experienced developers know that the hardest part of debugging usually is not fixing the bug, but finding where in the volumes of code the bug hides. By following the three rules in this article, you can help exceptions help you track down and eradicate bugs and make your programs more robust and user-friendly.

Waoo - Netbeans 6 is Available

Wed, 05 Dec 2007 02:53:00 +0000

The much awaited IDE NetBeans 6 is out today. In morning when i saw the email from net beans stating:
[nbannounce] NetBeans IDE 6.0 Available.
I couldn't stop myself from digging its features. It supports almost all current technologies and standard of Java/J2EE/Web Services/SOA.

Even, I ordered for a Free starter kit DVD. So why Don't you order or download the NetBeans 6 Today. NetBeans is easy to use IDE. Here is link to order a Starter Kit:

Get My Own NetBeans 6 Starter Kit

.
or Click the Image to get It:

NetBeans 6 DVD includes:
NetBeans IDE 6.0 with all packs
Java(TM) Platform Standard Edition Development Kit (JDK) 6.0 Update 3,
Java Tutorials,
NetBeans tutorials and screencasts.

Following Operating Systems are Supported:

Windows,
Linux,
Solaris x86,
Solaris SPARC
Mac OS X.
Currently, The NetBeans starter kit is available in English language, but very soon it will be available in other languages also.

So what are you waiting for. Just register and Get it.

Google Desktop Search - Awesome Tool

Sun, 14 Oct 2007 03:16:00 +0000

Hi Friends,

I found something very interesting something about google desktop search. I think, it is really useful to share with you people.

Google Desktop Search acts as your own personal Google Server and indexes the contents your system by file name, or in the case of select file formats, by the contents of the file. It runs on Windows XP and Windows 2000 (with Service Pack 3).

The free download indexes the full text of email created in Outlook or Outlook Express, Word documents, Excel spreadsheets, PowerPoint presentations, AOL Instant Messages, and caches the pages you view in Internet Explorer so you can revisit the page later "even if its live content has changed or you're offline."

The install is really simple and after you install it starts indexing. If you are working on your system then it will take a while to index. As soon as it realizes the machine is idle it starts churning away. After it indexes the data you are presented with a browser based interface much like the google we all know. Yes is it lightening fast, typing in JRun on my machine turned up 24,107 entries for files and 27,823 for web history, all that in .5 seconds. It looks through basically anything on your machine and indexes it. For free you can't beat this. it is on my short list of the best windows utilities I have ever used.

So what are you thinking, just download the Google Pack, It contains All the necessary softwares, which makes your PC useful....
Download it from Here

Manipulating String intelligently

Wed, 10 Oct 2007 06:51:00 +0000

Performance and Optimizations are the key features desired in Java Programming. So here are some examples, how to make improvement in your String manipulation..

String is the most encountered Objects in Java Programming. Till Tiger, we have 3 Classes to manipulate Strings. These are String, StringBuilder, StringBuffer.

String is immutable whereas StringBuffer and StringBuilder can change their values.

StringBuilder was introduced in J2SE5 or Tiger.The only difference between StringBuffer and StringBuilder is that StringBuilder is unsynchronized whereas StringBuffer is synchronized. So when the application needs to be run only in a single thread then it is better to use StringBuilder. StringBuilder is more efficient than StringBuffer.

Here are some examples given by Mr. Heinz Kabutz about how to perform String Manipulation intelligently.

We start with a basic concatenation based on +=:

public static String concat1(String s1, String s2, String s3,
String s4, String s5, String s6) {
String result = "";
result += s1;
result += s2;
result += s3;
result += s4;
result += s5;
result += s6;
return result;
}

String is immutable, so the compiled code will create many intermediate String objects, which can strain the garbage collector. A common remedy is to introduce StringBuffer, causing it to look like this:

public static String concat2(String s1, String s2, String s3,
String s4, String s5, String s6) {
StringBuffer result = new StringBuffer();
result.append(s1);
result.append(s2);
result.append(s3);
result.append(s4);
result.append(s5);
result.append(s6);
return result.toString();
}

But the code is becoming less legible, which is undesirable.

Using JDK 6.0_02 and the server HotSpot compiler, I can execute concat1() a million times in 2013 milliseconds, but concat2() in 734 milliseconds. At this point, I might congratulate myself for making the code three times faster. However, the user won't notice it if 0.1 percent of the program becomes three times faster.

Here's a third approach that I used to make my code run faster, back in the days of JDK 1.3. Instead of creating an empty StringBuffer, I sized it to the number of required characters, like so:

public static String concat3(String s1, String s2, String s3,
String s4, String s5, String s6) {
return new StringBuffer(
s1.length() + s2.length() + s3.length() + s4.length() +
s5.length() + s6.length()).append(s1).append(s2).
append(s3).append(s4).append(s5).append(s6).toString();
}

I managed to call that a million times in 604 milliseconds. Even faster than concat2(). But is this the best way to add the strings? And what is the simplest way?

The approach in concat4() illustrates another way:

public static String concat4(String s1, String s2, String s3,
String s4, String s5, String s6) {
return s1 + s2 + s3 + s4 + s5 + s6;
}

You can hardly make it simpler than that. Interestingly, in Java SE 6, I can call the code a million times in 578 milliseconds, which is even better than the far more complicated concat3(). The method is cleaner, easier to understand, and quicker than our previous best effort.

Sun introduced the StringBuilder class in J2SE 5.0, which is almost the same as StringBuffer, except it's not thread-safe. Thread safety is usually not necessary with StringBuffer, since it is seldom shared between threads. When Strings are added using the + operator, the compiler in J2SE 5.0 and Java SE 6 will automatically use StringBuilder. If StringBuffer is hard-coded, this optimization will not occur.

When a time-critical method causes a significant bottleneck in your application, it's possible to speed up string concatenation by doing this:

public static String concat5(String s1, String s2, String s3,
String s4, String s5, String s6) {
return new StringBuilder(
s1.length() + s2.length() + s3.length() + s4.length() +
s5.length() + s6.length()).append(s1).append(s2).
append(s3).append(s4).append(s5).append(s6).toString();
}

However, doing this prevents future versions of the Java platform from automatically speeding up the system, and again, it makes the code more difficult to read.

Source: By Mr. Heinz Kabutz(Java Champions) (creator of the free Java Specialists' Newsletter)

Calendar class - Better Way to Manipulate Dates.

Sun, 19 Aug 2007 09:17:00 +0000

Java’s Calendar class offers a set of methods for converting and manipulating temporal information. In addition to retrieving the current date and time, the Calendar class also provides an API for date arithmetic. Calendar’s built-in date/time arithmetic API is extremely useful.

This tutorial examines the Calendar class API and presents examples of how you can use Calendar objects to add and subtract time spans to and from dates and times, as well as how to evaluate whether one date precedes or follows another.

Adding time spans

Let’s say you want to add a time span to a starting date and print the result. Consider the following example, which initializes a Calendar to 16 July 2007 and then adds two months and three days to it to obtain a new value:

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.GregorianCalendar;

public class CalenderDemo{

 public static void main(String[] args) {

  CalenderDemo tdt = new CalenderDemo();

  tdt.calculateDate();

 private void calculateDate(){

  //Creating a calendar instance with initial date
 16July 2007

  Calendar calendar = new GregorianCalendar
                        (2007,Calendar.JULY,16);

  System.out.println("Initial date is: ");

  printFormattedDate(calendar);

  // Adding 2 Months and 3 day here

  calendar.add(Calendar.MONTH,2);

  calendar.add(Calendar.DAY_OF_MONTH,3);

  // printing modified date value

  System.out.println("New date is: ");

  printFormattedDate(calendar);

 /** Method to print Formatted Date
    SimpleDateFormat  */

 private void printFormattedDate(Calendar calendar){

  // define output format and print

  SimpleDateFormat sdf = new SimpleDateFormat
                            ("d MMM yyyy hh:mm aaa");

  String date = sdf.format(calendar.getTime());

  System.out.println(date);

The main workhorse of this class is the doMath() method, which begins by initializing a new GregorianCalendar object to 16 July 2007. Next, the object’s add() method is invoked; this method accepts two arguments: the name of the field to add the value to and the amount of time to be added. In this example, the add() method is called twice — first to add two months to the starting date and then to add a further one day to the result. Once the addition is performed, the printCalendar() utility method is used to print the final result.

The use of the SimpleDateFormat object to turn the output of getTime() into a human-readable string. This class is a part of java.text. package.

When you run the class, this is the output you’ll see:

Initial date is:

 16 July 2007 12:00 AM

New date is:

 19 September 2007 12:00 AM

This kind of addition also works with time values. To illustrate, consider the next example, which adds 14 hours and 55 minutes to a starting time value:

/*

* Creating an Instance of Calendar with Year,
* Month, data, Hours and Minutes **/

Calendar calendar =new GregorianCalendar
                (2007,Calendar.JANUARY,1, 1,0);

System.out.println(“Initial Date is :”);

printFormattedDate(calendar);   
                //Defined in Above example

 // Add 14h 55min

calendar.add(Calendar.HOUR,14);

calendar.add(Calendar.MINUTE,55);

//Print after Adding the hours and minutes

System.out.println(“Modified Date is :”);

printFormattedDate(calendar);  //Defined in Above example.

This is almost identical to the previous class except
that the calls to add() involve the calendar’s hour
and minute fields. Here’s the output:

Initial Date is:

1 Jan 2007 01:00 AM

Modified Date is
1 Jan 2007 03:55 PM

Subtracting time spans

Subtraction is fairly easy as well — you simply use negative values as the second argument to add(). Here’s an example:

// Creating a Date Instance with Year, Month, Day, Hours and Minutes

Calendar calendar = new GregorianCalendar
                   (2007,Calendar.JANUARY,2, 3,30);

System.out.println("Starting date is: ");

printFormattedDate(calendar);
//Defined in First Example.

// Subtracting 1 Year 1 Day 4 Hours and 5 Minutes

System.out.println("Subtracting 1 Year 1
                 Day 4 Hours and 5 Minutes");

calendar.add(Calendar.YEAR,-1);

calendar.add(Calendar.DAY_OF_MONTH,-1);

calendar.add(Calendar.HOUR,-4);

calendar.add(Calendar.MINUTE,-5);

// print result

System.out.println("Ending date is ");

printFormattedDate(calendar);

Here’s the output:

Starting date is:

2 Jan 2007 03:30 AM

Subtracting 1y 1d 4h 5min...

Ending date is

31 Dec 2005 11:25 PM

In this example, the Calendar object automatically takes care of adjusting the year and the day when the subtraction results in the date “overflowing” from 1 Jan 2006 to 31 Dec 2005.

Adding vs. rolling

As the previous example illustrates, the add() method automatically takes care of rolling over days, months, and years when a particular calendar field “overflows” as a result of addition or subtraction. However, this behavior is often not what you want. In those situations, the Calendar object also has a roll() method, which avoids incrementing or decrementing larger calendar fields when such overflow occurs. To see how this works, look at the following example:

Calendar calendar = new GregorianCalendar
                    (2006, Calendar.DECEMBER,1);

System.out.println("Starting date for add()  is: ");

printFormattedDate(calendar);

System.out.println("After add()ing 1 month, ending date is: ");

calendar.add(Calendar.MONTH, 1);

printFormattedDate(calendar);

// initialize calendar

Calendar calendar2 = new GregorianCalendar
              
(2006, Calendar.DECEMBER,1);

System.out.println("Starting date for roll() is: ");

printFormattedDate(calendar2);

System.out.println("After roll()ing 1 month,  ending date is: ");

Calendar2.roll(Calendar.MONTH, 1);

printFormattedDate(calendar2);

Here’s the output:

Starting date for add() is:

 1 Dec 2006 12:00 AM

 After add()ing 1 month, ending date is:

 1 Jan 2007 12:00 AM

 Starting date for roll() is:

 1 Dec 2006 12:00 AM

 After roll()ing 1 month, ending date is:

 1 Jan 2006 12:00 AM

In the first case, when one month is added to the starting date of 1 Dec 2006, the add() method realizes that a year change will occur as a result of the addition, and the year is rolled over to 2007. When using roll(), this behavior is disabled, and only the month field is incremented by 1, with the year change ignored. In many situations, roll() is very useful.

Checking date precedence

The Calendar object also includes the compareTo() method, which lets you compare two dates to find out which one comes earlier. The compareTo() method accepts another Calendar object as an input argument and returns a value less than zero if the following conditions are true:

The date and time of the input Calendar object is later than that of the calling Calendar object.
A value greater than zero if the reverse is true.
A value of 0 if the two Calendar objects represent the same date.

Here’s an example that compares 1 Jan 2007 12:00 AM and 1 Jan 2007 12:01 AM with compareTo():

// initialize two calendars

Calendar calendar1 = new GregorianCalendar
                   (2007,Calendar.JANUARY,1,0,0,0);

Calendar calendar2 = new GregorianCalendar
                   (2007,Calendar.JANUARY,1,0,1,0);

// define date format

String date1 = null;

String date2 = null;

SimpleDateFormat sdf = new SimpleDateFormat
                   ("d MMM yyyy hh:mm aaa");

// compare dates

if((calendar1.compareTo(calendar2)) <>    date1 = sdf.format(calendar1.getTime());
    date2 = sdf.format(calendar2.getTime());
}else{
    date1 = sdf.format(calendar2.getTime());
    date2 = sdf.format(calendar1.getTime());
}
System.out.println(date1 + " occurs before " + date2);
System.out.println(date2 + " occurs after  " + date1);
  Here’s the output:
  1 Jan 2007 12:00 AM occurs before 1 Jan 2007 12:01 AM
1 Jan 2007 12:01 AM occurs after  1 Jan 2007 12:00 AM
  

Since Most of the Date/Time classes are deprecated,
Calendar class is very handy to work with.
Alongwith this java.text.DateFormat and
java.text.SimpleDateFormat are very useful to
convert the date to different Locales and
different format.

Reflection APIs - A way to inspect classes at runtime

Thu, 09 Aug 2007 09:13:00 +0000

Java Reflection is a technology that looks inside a Java object at runtime and sees basically everything about the object that you would know at compile time.

Java Reflection is a technology that looks inside a Java object at runtime and sees what variables it contains, what methods it supports, what interfaces it implements, what classes it extends—basically everything about the object that you would know at compile time.

The Reflection API is located in the java.lang.reflect package and is included in any J2SE installation. Primarily it is intended for very generic programs such as database browsers or visual code editors, but it can be used in any other applications. Reflection is for

Basic techniques

There are two basic techniques involved in Reflection: discovery and use by name. Here are descriptions of both:

Discovery involves taking an object or class and discovering the members, superclasses, implemented interfaces, and then possibly using the discovered elements.
Use by name involves starting with the symbolic name of an element and using the named element.

Discovery typically starts with an object and then calls the Object.getClass() method to get the object's Class. The Class object has a number of methods for discovering the contents of the class. Here are some of those methods:

getMethods(): returns an array of Method objects representing all of the public methods of the class or interface.
getConstructors(): returns an array of Constructor objects representing all of the public constructors of the class.
getFields(): returns an array of Field objects representing all of the public fields of the class or interface.
getClasses(): returns an array of Class objects representing all of the public classes and interfaces that are members (e.g., inner classes) of the class or interface.
getSuperclass(): returns the Class object representing the superclass of the class or interface (null is returned for interfaces).
getInterfaces(): returns an array of Class objects representing all of the interfaces that are implemented by the class or interface.

You can obtain the Class object either through discovery, by using the class literal (e.g., MyClass.class), or by using the name of the class (e.g., Class.forName("mypackage.MyClass")). With a Class object, member objects Method, Constructor, or Field can be obtained using the symbolic name of the member. These are the most important techniques:

getMethod("methodName", Class...): returns the Method object representing the public method with the name "methodName" of the class or interface that accepts the parameters specified by the Class... parameters.
getConstructor(Class...): returns the Constructor object representing the public constructor of the class that accepts the parameters specified by the Class... parameters.
getField("fieldName"): returns the Field object representing the public field with the name "fieldName" of the class or interface.

You can use Method, Constructor, and Field objects to dynamically access the represented member of the class. For example:

Field.get(Object): returns an Object containing the value of the field from the instance of the object passed to get(). (If the Field object represents a static field, the Object parameter is ignored and may be null.)
Method.invoke(Object, Object...): returns an Object containing the result of invoking the method for the instance of the first Object parameter passed to invoke(). The remaining Object... parameters are passed to the method. (If the Method object represents a static method, the first Object parameter is ignored and may be null.)
Constructor.newInstance(Object...): returns the new Object instance from invoking the constructor. The Object... parameters are passed to the constructor. (Note that the parameterless constructor for a class can also be invoked by calling newInstance().)

Creating arrays and proxy classes

The java.lang.reflect package provides an Array class that contains static methods for creating and manipulating array objects. Since J2SE 1.3, the java.lang.reflect package also provides a Proxy class that supports dynamic creation of proxy classes, which implement specified interfaces.

The implementation of a Proxy class is provided by a supplied object that implements the InvocationHandler interface. The InvocationHandler's method invoke (Object, Method, Object[]) is called for each method invoked on the proxy object—the first parameter is the proxy object, the second parameter is the Method object representing the method from the interface implemented by the proxy, and the third parameter is the array of parameters passed to the interface method. The invoke() method returns an Object result that contains the result returned to the code that called the proxy interface method.

Eaxmple of Reflection is :

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Member;

import static java.lang.System.out;

enum ClassMember { CONSTRUCTOR, FIELD, METHOD, CLASS, ALL }

public class ClassSpy {

    public static void main(String... args) {

               try {

                   Class c = Class.forName(args[0]);

                   out.format("Class:%n  %s%n%n", c.getCanonicalName());

                   Package p = c.getPackage();

                   out.format("Package:%n  %s%n%n",

                                      (p != null ? p.getName() : "-- No Package --"));

                   for (int i = 1; i <>

                               switch (ClassMember.valueOf(args[i])) {

                               case CONSTRUCTOR:

                                   printMembers(c.getConstructors(), "Constructor");

                                   break;

                               case FIELD:

                                   printMembers(c.getFields(), "Fields");

                                   break;

                               case METHOD:

                                   printMembers(c.getMethods(), "Methods");

                                   break;

                               case CLASS:

                                   printClasses(c);

                                   break;

                               case ALL:

                                   printMembers(c.getConstructors(), "Constuctors");

                                   printMembers(c.getFields(), "Fields");

                                   printMembers(c.getMethods(), "Methods");

                                   printClasses(c);

                                   break;

                               default:

                                   assert false;

        // production code should handle these exceptions more gracefully

               } catch (ClassNotFoundException x) {

                   x.printStackTrace();

    private static void printMembers(Member[] mbrs, String s) {

               out.format("%s:%n", s);

               for (Member mbr : mbrs) {

                   if (mbr instanceof Field)

                               out.format("  %s%n", ((Field)mbr).toGenericString());

                   else if (mbr instanceof Constructor)

                               out.format("  %s%n", ((Constructor)mbr).toGenericString());

                   else if (mbr instanceof Method)

                               out.format("  %s%n", ((Method)mbr).toGenericString());

               if (mbrs.length == 0)

                   out.format("  -- No %s --%n", s);

               out.format("%n");

    private static void printClasses(Class c) {

               out.format("Classes:%n");

               Class[] clss = c.getClasses();

               for (Class cls : clss)

                   out.format("  %s%n", cls.getCanonicalName());

               if (clss.length == 0)

                   out.format("  -- No member interfaces, classes, or enums --%n");

               out.format("%n");

Further References:

http://java.sun.com/docs/books/tutorial/reflect/index.html

Java Singleton Pattern : Potential Problems and Solutions

Fri, 27 Jul 2007 04:16:00 +0000

The Java Singleton pattern belongs to the family of design patterns that governs the instantiation process. This design pattern suggests that at any time there can only be one instance of a Singleton (object) created by the JVM. You implement the pattern by creating a class with a method that creates a new instance of the class if one does not exist. If an instance of the class exists, it simply returns a reference to that object.

How the Singleton pattern works:

Here’s a typical example of Singleton:

public class Singleton {

        private final static Singleton INSTANCE = new Singleton();

      // Private constructor suppresses generation of

    // a (public) default constructor

    private Singleton() {}

    public static Singleton getInstance() {

      return INSTANCE;

The classic Singleton does not use direct instantiation of a static variable with declaration — it instantiates a static instance variable in the constructor without checking to see if it already exists:

public class ClassicSingleton {

    private static ClassicSingleton INSTANCE = null;

    private ClassicSingleton() {

       // Exists only to defeat instantiation.

    public static ClassicSingleton getInstance() {

       if(INSTANCE == null) {

          INSTANCE = new ClassicSingleton();

       return INSTANCE;

Or alternative way is :

public class ClassicSingleton {

    private static ClassicSingleton INSTANCE = null;

    static{

                 INSTANCE = new ClassicSingleton();

    private ClassicSingleton() {

       // Exists only to defeat instantiation.

    public static ClassicSingleton getInstance() {

       return INSTANCE;

The static construct ensure that the object is created when the class is loaded by the JVM. The Singleton class’s default constructor is made private, which prevents the direct instantiation of the object by other classes using the new keyword. A static modifier is applied to the instance method that returns the Singleton object; it makes this a class level method that can be accessed without creating an object.

When you need Singleton

Singletons are truly useful when you need only one instance of a class, and it is undesirable to have more than one instance of a class.

When designing a system, you usually want to control how an object is used and prevent users (including yourself) from making copies of it or creating new instances. For example, you can use it to create a connection pool. It’s not wise to create a new connection every time a program needs to write something to a database; instead, a connection or a set of connections that are already a pool can be instantiated using the Singleton pattern.

The Singleton pattern is often used in conjunction with the factory method pattern to create a systemwide resource whose specific type is not known to the code that uses it. An example of using these two patterns together is the Abstract Windowing Toolkit (AWT). In GUI applications, you often need only one instance of a graphical element per application instance, like the Print dialog box or the OK button.

Check out for potential problems

Although the Singleton design pattern is one of the simplest design patterns, it has some limitations.

Construct in multi-threaded applications
You must carefully construct the Singleton pattern in multi-threaded applications. If two threads are to execute the creation method at the same time when a Singleton does not exist, both must check for an instance of the Singleton, but only one thread should create the new object. The classic solution to this problem is to use mutual exclusion on the class that indicates that the object is being instantiated. This is a thread-safe version of a Singleton:

public class Singleton

   // Private constructor suppresses generation

   //  of a (public) default constructor

   private Singleton() {}

   private static class SingletonHolder{

     private final static Singleton INSTANCE = new Singleton();

   public static Singleton getInstance(){

     return SingletonHolder.INSTANCE;

For an alternative solution, you can add the synchronized keyword to the getInstance() method declaration:

   public static synchronized Singleton getInstance()

Think ahead about cloning prevention
You can still create a copy of the Singleton object by cloning it using the Object’s clone() method. To forbid this, you need to override the Object’s clone method, which throws a CloneNotSupportedException exception:

      public Object clone() throws CloneNotSupportedException {

         throw new CloneNotSupportedException();

Consider making the singleton class final
You may want to make the Singleton class final to avoid sub classing of Singletons that may cause other problems.

Remember about garbage collection
Depending on your implementation, your Singleton class and all of its data might be garbage collected. This is why you must ensure that there must be a live reference to the Singleton class when the application is running.

The Singleton pattern is widely used and has proved its usability in designing software. Although the pattern is not specific to Java, it has become a classic in Java programming.

Struts Are the Really Very Beautiful..................

Fri, 05 Jan 2007 07:53:00 +0000

Three Days Before Struts started in Training program. I Heard that Struts are very difficult to understand. But After three days, I found how beautifully they are designed by the Craig R. McClanahan.

I also learned Here in current company that learning the concepts is very neccessary rather than just gulping the APIS. I really thank our instructor for this.

Hey I m not going to write about the struts, since web is just full of such kind of material. The spirit is to force urself to learn the basics of anything. Technology may change not the basic concepts.

Time to Take a Break.

Exams Season of Tension, Isn't It?

Thu, 23 Nov 2006 11:53:00 +0000

Exams are going on, Tension is also there. But Exams should be there to test us, otherwise we''l become Lazy.....

Isn't IT?

Hey Proud to be an Indian.

Thu, 17 Aug 2006 10:08:00 +0000

Hi day before yesterday, it was 59th Independance Day. We seen the as usual 15th august parade & just enjoyed another holiday. But we r forgetting the meaning of the day. On this day, i remembered what our President said in 'Ignited Minds'. His mission of transforming India into a developed country. Youth like us need to think abt it seriously. We can do this simply by performing our duties like not paying bribes, oppose the curruption, just switching the electric equipments, by keeping our environment clean, etc. By making people aware abt their fundamental duties & rights.

Everyone need to do his share of work in transforming India into a developed. Lets make a commitment to ourself that we'll do these small things & help our country.

In this way only, we'll find true meaning of these days like 15th August, 26 Janauary, etc.

Ok bye for now, i m coming back soon...
Ashish

Exams are Boaring, Are U agree...................

Thu, 20 Apr 2006 08:39:00 +0000

Hey frens,

Exams are drawing near, sleepless nights, restless days & many more symptoms can be seen of examfobia. When we talk abt exams people start reacting in abnormal ways. Why people fear from the exams. The reasons may be, know to everybody. But here are some benefits of exams i expericed during exam periods.

First , the mind start working at a great speed eg. people can pass exams with the preparation on only 15 days.

Second, the subjects which are not understandable to u, are become so clear to that u start feeling that I'll teach the subject from Next Year.

Many people may found another benefits of exams too, Can we share it sothat people start loving exams.. Do U think, Days like That'll come?

Believe in urself to get good Results

Fri, 07 Apr 2006 07:16:00 +0000

Hi frens,

Some time before i was always think Paper Presentaion in some National Level Paper Presenation contests is very big think. It need a lot of hard work & as well as intelligence.
I thought at that time whether i would be able to present my own paper in such contests or not.

Few Days Back, there was such competetion in our college. My Head of Department inspired me to present a paper. He told me that i can present a perper very well. I thought & accepted his offer.

I asked him about guidelines of it. I choose a topic for it & started prepring for it. Also I presented in a satisfactory way.

Now I m taking part in another such compitetion, & my paper is also got selected for it. Now i feel quite good. I think it's a result of believing in myself. Nothing is impossible, if u think like this & work for it.

So start beleving in urself, respect urself & love urself.........

Mediataion- Knowing Urself in a Better way

Tue, 21 Mar 2006 12:57:00 +0000

Life is like fun, if u able to enjoy it. Itsn't It? We are just leaving our lives in a very careless way.Most of us are not aware of the very tiny things that are much enjoyable & gives healing affects.
Meditation makes u more siencere not serious. Some people think that meditation is a state when u feel nothing(like sleep). But Meditation is to know urself in a batter way. Last week, i met with a person who have different kinds of mediations for different kind of problems.

Two of them i know now.

Such Experimentation are nice & give fruitful results. But one thing is really important, before starting it, u feel that it is going to work for u. Only then u can get much benefit of it.

Meditate to Know the Nature & Urself.

Fri, 17 Mar 2006 07:35:00 +0000

Hi Frens ,
There are things which can't be forget through out ur life like frens, fun & similar many more. Friends-Few Relations In Earth Never Dies. They are like mirror where u can watch ur urself with ur cons.
I believe personally, that everybody should have a few frens, Frens are nither Bad nor Good, They are just Frens.
So, Can we become frens, for this I can remain ur fren for life....
Enjoy Life, Have fun & Don't Forget Ur Aim......

Ashish Mishra

Holi- How Was It?

Thu, 16 Mar 2006 10:45:00 +0000

Hi frens,

Yesterday, We celebrated the Holi, It's is known as festival of colors, Colors of joy, happiness, prosparity, victory , etc.

The craze of this festival is decreasing year after year, can somebody tell me about the reason behind it?

What i had found, that people are no more interested in such festivals. It because of the environment & way of celebrating are not worthy. People user dark colors which are bad in quality & chemicals. Some people use synthetic paints, mud etc.
Such things are really disgusting.
Such things are hurting the feeling of people, & should be avoided.

Then people'll will able to celebrate Holi with joy & delight.

Have U Seen My Web-site

Mon, 06 Mar 2006 10:36:00 +0000

Hi friends,

I had just uploaded my web pages at www.geocities.com/ashish4u4ever2003.
It's was fun, i found it very easy. Now i m feeling quite relaxed. I had broken my promise to my senior, that i will upload my web-page is 15 days, I m really sorry for it, Kuldeep Sir.

But i am still thinking that he can forget me for this, since i had done in after 2 days, of given deadline.

I had created six pages, but they are not complete still, two pages are still not fully complete.
I had tried hard for it, please watch it, and send me the response on my mail
ashish.mishra16@gmail.com

ur fren
Ashish Mishra