Technical notes

Best Practices for Secure Coding: A Guide for Developers

2024-07-22T16:37:00.005+05:30

In today’s digital age, writing secure code is essential to protect software from hackers and keep user data safe. This guide outlines best practices for secure coding, helping developers build robust and secure applications.

Why Secure Coding Matters

Protecting User Data: Secure coding keeps user information private and safe from unauthorized access.
Preventing Cyberattacks: Good coding practices reduce the risk of attacks like SQL injection, cross-site scripting (XSS), and buffer overflows.
Ensuring Compliance: Following secure coding standards helps meet legal requirements and industry standards.
Maintaining Reputation: Security breaches can harm your product's reputation. Secure coding maintains user trust and confidence.

Best Practices for Secure Coding

1. Validate User Inputs

Always check and clean user inputs to prevent malicious data from causing harm.

<input type="text" pattern="[A-Za-z0-9]+" title="Only alphanumeric characters are allowed">

2. Use Parameterized Queries

Avoid SQL injection by using parameterized queries instead of embedding user inputs directly into SQL statements.

// Example in Java using PreparedStatement
String query = "SELECT * FROM users WHERE username = ?";
PreparedStatement pstmt = conn.prepareStatement(query);
pstmt.setString(1, username);
ResultSet rs = pstmt.executeQuery();

3. Implement Strong Authentication and Authorization

Ensure users are who they say they are and control their access to different parts of your application.

// Example of role-based access control in Node.js
function authorize(role) {
    return (req, res, next) => {
        if (req.user && req.user.role === role) {
            next();
        } else {
            res.status(403).send('Forbidden');
        }
    };
}

4. Use HTTPS

Encrypt data sent over the internet using HTTPS to protect it from being intercepted.

5. Manage Sessions Securely

Use secure cookies, set appropriate session timeouts, and invalidate sessions upon logout.

// Example of setting secure cookies in Express.js
app.use(session({
    secret: 'your-secret-key',
    resave: false,
    saveUninitialized: true,
    cookie: { secure: true, httpOnly: true }
}));

6. Keep Dependencies Updated

Regularly update libraries and dependencies to fix known security issues. Use tools like npm audit to check for vulnerabilities.

7. Secure Error Handling

Don’t expose sensitive information in error messages. Log errors for debugging but show generic messages to users.

Conclusion

Secure coding is a crucial part of software development. By following these best practices, developers can build safer, more reliable applications that protect user data and maintain trust.

Optimizing MySQL Queries: A Deep Dive into Indexing and STRAIGHT_JOIN

2020-08-19T13:31:00.010+05:30

When working with MySQL, optimizing query performance is crucial. Before finalizing my queries, I always use MySQL Workbench to explain the query plan, ensuring optimal performance. However, I’ve noticed that performance can vary, especially with queries involving joins on multiple tables. Indexing my tables often helps, but sometimes even with appropriate indexes, the expected performance boost isn’t there.

Recently, I encountered a query that wasn’t performing well despite adding the right index. MySQL Workbench revealed that MySQL wasn’t using the new index. After some experimentation, I found that using FORCE INDEX made MySQL utilize the index. However, forcing MySQL to use an index didn’t feel like the best solution. I wanted MySQL to optimize the query automatically.

Discovering STRAIGHT_JOIN

During my research, I came across STRAIGHT_JOIN. Adding this to my query immediately made MySQL use the index without any force. This led me to explore the differences between STRAIGHT_JOIN and INNER JOIN.

How STRAIGHT_JOIN Works

STRAIGHT_JOIN is similar to an INNER JOIN in that it returns matching records from the joined tables. The key difference is that STRAIGHT_JOIN enforces the join order of the tables. Unlike INNER JOIN, which allows MySQL to choose the join order, STRAIGHT_JOIN reads the left table first, then the right table. Generally, the table with the smaller result set should be on the left. However, out of habit, we often put the larger table on the left.

Optimizing Query Plans

Just placing the correct table on the left isn’t always sufficient. The MySQL optimizer sometimes picks a suboptimal query plan, ignoring the appropriate index. This doesn’t mean we should always use STRAIGHT_JOIN over INNER JOIN.

Best Practices for Query Optimization

Use EXPLAIN: Always use EXPLAIN to analyze your query and understand how MySQL plans to execute it.
Indexing: Ensure your tables are indexed appropriately.
Query Restructuring: Restructure your query if the performance isn’t optimal.
Consider STRAIGHT_JOIN: If all else fails, using STRAIGHT_JOIN can be a last resort to guide MySQL’s query execution order.
Monitor and Adapt: Regularly monitor query performance. As your tables grow and indexes evolve, what was once an optimal query might become suboptimal.

Remember, while STRAIGHT_JOIN can be powerful, it should not be your default choice. Let MySQL’s optimizer do its job and intervene only when necessary. Over time, table growth and index changes can make previously optimal queries less efficient. Stay flexible and adapt your queries as your database evolves.

By following these practices, you can ensure that your MySQL queries remain efficient and your database performance stays robust.

Automate File Transfer to Remote Server Using Ant Build in Eclipse

2020-08-13T20:35:00.008+05:30

Automate File Transfer to Remote Server Using Ant Build in Eclipse

Working on a project often involves copying files to a remote server. Manually transferring files via SFTP tools can be tedious and time-consuming. During one such project, I wondered if Ant Builder, which is capable of copying files between directories, could also handle copying files to a remote server.

After some research and experimentation, I found a solution that works perfectly. Now, my local files are automatically copied to a remote server using Ant Build. I simply build my project in Eclipse, and the files are pushed to the server. All that’s left is to refresh the web page, as the server development environment seamlessly integrates with my local setup.

Step-by-Step Guide to Copy Files to a Remote Server Using Ant Build

1. Download the Necessary JAR File

First, download the jsch-0.1.55.jar file, which enables secure file transfer.

2. Add the JAR to Eclipse

Add the jsch-0.1.55.jar to your Eclipse Ant classpath:

Navigate to C:\eclipse_folder_path\plugins\org.apache.ant_1.10.8.v20200515-1239\lib and place the JAR file there.
Open Eclipse and go to Preferences.
In the Ant/Runtime entry, go to the Classpath tab.
Click Add External Jars and add the jsch.jar to Ant's classpath.

3. Modify Your Ant Build Script

Update your Ant Build script to include the SCP (Secure Copy Protocol) task instead of the standard copy command. Use the following line:

<scp todir="user_name@remote_server_url:/path_to_remote_dir/" password="your_password" trust="true">
    <fileset dir="path_to_local_dir"/>
</scp>

Benefits of Automating File Transfer

Automating the file transfer process using Ant Build offers several advantages:

Efficiency: Saves time by eliminating manual file transfers.
Consistency: Ensures that files are copied correctly every time.
Integration: Seamlessly integrates with your development workflow in Eclipse.

Conclusion

By following these steps, you can automate the process of copying files from your local machine to a remote server using Ant Build in Eclipse. This not only streamlines your workflow but also enhances productivity by turning server development into a local-like experience.

Give it a try and enjoy the convenience of automated file transfers!

How to schedule a periodic task in Java?

2016-10-10T12:31:00.002+05:30

Scheduling tasks in Java is a common requirement in various applications, such as running a periodic cleanup, sending regular notifications, or updating cached data. In this guide, we'll show you how to schedule tasks periodically using the Timer and TimerTask classes in Java.

Steps to Schedule a Task Periodically in Java

Create a Timer Object
First, create an instance of the Timer class. This class is responsible for scheduling tasks.

Timer timer = new Timer();
Create a TimerTask Object
Next, create an instance of the TimerTask class and override its run() method. This method contains the code you want to execute periodically.
```
TimerTask task = new TimerTask() {
    @Override
    public void run() {
        // Call your task here
        System.out.println("Task is running");
    }
};
```
Schedule the Task
Finally, use the schedule() method of the Timer class to schedule the task. You need to specify the task, delay, and period.

timer.schedule(task, delay, period);

Here:
- task - The task to be scheduled. Pass the task object created in step 2.
- delay - Delay in milliseconds before the task is to be executed.
- period - Time in milliseconds between successive task executions.

Example: Scheduling a Task to Run Every 5 Seconds

Let's look at a complete example where we schedule a task to run every 5 seconds after an initial delay of 2 seconds:

import java.util.Timer;
import java.util.TimerTask;

public class PeriodicTaskScheduler {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Task is running");
            }
        };
        timer.schedule(task, 2000, 5000);
    }
}

Why Use Timer and TimerTask in Java?

Using Timer and TimerTask in Java allows you to manage periodic tasks efficiently. These classes are simple to use and provide a straightforward way to execute tasks at fixed intervals. This can be particularly useful for:

Automated backups
Scheduled notifications
Periodic data synchronization
Regular maintenance tasks

Conclusion

Scheduling tasks periodically in Java is a breeze with Timer and TimerTask. By following the steps outlined above, you can ensure that your tasks run at the desired intervals without manual intervention.

For more information on Java scheduling, check out the Java Timer documentation.

Understanding System.out.println() in Java: A Deep Dive into Java's Console Output

2013-12-10T14:24:00.004+05:30

Understanding System.out.println() in Java

System.out.println() is a fundamental method in Java used for printing messages to the console. It is widely used for debugging, logging, and general output purposes.

What is System.out.println() in Java?

System.out.println() is a method provided by the Java standard library to print a line of text to the standard output stream, typically the console or terminal.

Key Points about System.out.println()

Usage: Used to print messages to the console.
Functionality: Outputs text followed by a newline character.
Output Stream: Writes to the standard output stream (often the console).

Understanding "out" in System.out.println()

The "out" in System.out.println() is a static member variable of the System class. It is initialized to refer to the standard output stream.

Example Usage of System.out.println()

Here's an example demonstrating the use of System.out.println() to print "Hello, World!" to the console:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Conclusion

System.out.println() is a simple yet powerful method in Java for outputting messages to the console. It forms a basic tool for developers to communicate with the standard output stream during program execution.

Understanding Method Overloading and Overriding in Java

2013-12-10T14:21:00.003+05:30

Method overloading and overriding are fundamental concepts in Java that often lead to confusion. Let's clarify these concepts with clear examples and explanations.

What is Method Overloading?

Method overloading occurs when multiple methods in the same class have the same name but different parameters. Here are the conditions for method overloading:

1. Number of parameters is different.
2. Parameter types are different.

Examples of Valid and Invalid Method Overloading

Let's look at some examples to understand what constitutes valid method overloading:

// Valid overloading - different parameter types
int changeDate(int year);
int changeDate(float year);

// Invalid overloading - same parameter types, different return types
int changeDate(int month);
float changeDate(int year);

What is Method Overriding?

Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. The overriding method must have the same method name, parameters, and return type.

Key Differences Between Overloading and Overriding

Overloading changes the method signature within the same class, while overriding provides a new implementation of an inherited method in a subclass without changing the method signature.

Conclusion

Understanding the differences between method overloading and overriding is crucial for writing efficient and maintainable Java code. Use overloading to provide multiple ways to invoke a method, and use overriding to customize inherited behavior in subclasses.

The Difference Between Class and Object in Java

2013-12-10T14:19:00.003+05:30

In Java programming, understanding the distinction between 'class' and 'object' is essential. While they are related concepts, each serves a distinct purpose in object-oriented programming.

What is a Class?

A class in Java is a blueprint or template that defines the structure and behavior of objects. It contains attributes (fields) and methods that define the object's state and behavior. Here's a simplified definition:

"A class is a static piece of code that defines the attributes and methods shared by all instances (objects) of that class."

What is an Object?

An object is an instance of a class. It represents a specific entity that exists at runtime and has its own state (attributes) and behavior (methods). Unlike classes, objects are dynamic and exist only during the program's execution:

"An object is a specific instance of a class, created at runtime with its own set of attributes and methods."

Example: Class vs. Object

Consider a class Animal with attributes like species and age:

public class Animal {
    String species;
    int age;

    public Animal(String species, int age) {
        this.species = species;
        this.age = age;
    }

    public void eat() {
        System.out.println("The animal is eating.");
    }
}

Creating objects of the Animal class:

Animal lion = new Animal("Lion", 5);
Animal cat = new Animal("Cat", 2);

Key Differences:

Class: Defines the structure and behavior shared by all instances.
Object: Represents a specific instance with its unique state and behavior.

Conclusion

Understanding the distinction between class and object is fundamental in Java programming. Classes provide the blueprint, while objects are the tangible instances that embody those blueprints.

Understanding Abstract Classes and Interfaces in Java

2013-12-10T14:12:00.002+05:30

Abstract classes and interfaces are fundamental concepts in Java programming, each serving distinct purposes in defining class hierarchies and contracts for implementing classes.

Abstract Classes

Abstract classes in Java are declared with the abstract keyword. They cannot be instantiated on their own and are designed to be inherited by subclasses. They may contain abstract methods—methods without a body—that subclasses must implement.

When to Use Abstract Classes

Use abstract classes when you want to provide a default implementation that subclasses can override.
Abstract classes are suitable when you have a strong relationship between the base class and its subclasses.
They allow you to define non-public members, such as protected fields and methods.

Interfaces

Interfaces in Java define a contract that classes can choose to implement. They contain method signatures but no implementation details. A class can implement multiple interfaces but can extend only one class.

When to Use Interfaces

Use interfaces when you want to provide a common behavior to unrelated classes.
They are ideal for achieving abstraction and supporting multiple inheritance-like behavior.
Interfaces are a good choice when you want to create a plugin-like architecture.

Key Differences Between Abstract Classes and Interfaces

Abstract classes can have method implementations, constructors, and fields, whereas interfaces cannot.
A class can extend only one abstract class but can implement multiple interfaces.
Abstract classes are suitable for inheritance hierarchies, while interfaces are more flexible for defining contracts.

Conclusion

Choosing between abstract classes and interfaces depends on your design goals. Abstract classes are used for code reusability and defining a base class, while interfaces offer flexibility and multiple inheritance-like behavior. Understanding these concepts is crucial for designing effective and maintainable Java applications.

Introduction to Java Programming: Classes, Objects, Methods, and Syntax

2013-10-05T17:12:00.002+05:30

When considering a Java program, it consists of objects communicating by invoking each other's methods. Let's delve into the concepts of classes, objects, methods, and instance variables:

Object - Objects in Java encapsulate states (e.g., color, name, breed) and behaviors (e.g., wagging, barking, eating). Each object is an instance of a class.
Class - A class serves as a blueprint or template defining the behaviors and states that objects of its type support.
Methods - Methods represent the behaviors of a class. They contain the logic, manipulate data, and execute actions within a program.
Instance Variables - Every object possesses its own set of instance variables. These variables determine the state of an object by holding assigned values.

First Java Program:

Let's start with a simple Java program that prints "Hello World".


public class MyFirstJavaProgram {

    public static void main(String[] args) {
       System.out.println("Hello World");
    }
}

To compile and run the program, follow these steps:

Open a text editor (e.g., Notepad) and enter the code above.
Save the file as MyFirstJavaProgram.java.
Open a command prompt, navigate to the directory where the file is saved (e.g., C:\), and compile the code with javac MyFirstJavaProgram.java.
If there are no errors, run the program with java MyFirstJavaProgram.
You should see "Hello World" printed on the console.

Basic Syntax:

Key points to remember about Java syntax:

Case Sensitivity - Java is case-sensitive, distinguishing between Hello and hello.
Class Names - Begin with an uppercase letter; use uppercase for each inner word. Example: MyFirstJavaClass.
Method Names - Begin with a lowercase letter; use uppercase for each inner word. Example: public void myMethodName().
Program File Name - Must match the class name exactly. Save as MyFirstJavaProgram.java.
public static void main(String args[]) - Entry point for Java programs; must be included in every Java application.

How to delete first preceding element?

2013-03-25T13:06:00.004+05:30

Here is the html from which I want to remove the div element 'div' by clicking the link.

    <div>
          <a href="javascript:void(0)" class="link">My link</a>
    </div>

To access the preceding element I will use the .parents() method of jQuery and then call

the method .remove() to remove the 'div' element.

Here is the code...

    $('a.link').click(function() {
    	$(this).parents('div:first').remove();
    });

HBootstrap Basics: A Simple Guide

2013-03-25T11:54:00.001+05:30

Explore Bootstrap basics through a simple HTML setup. Let's create a foundational template:

To start, ensure your HTML includes:

Proper document structure with <!DOCTYPE html>
Basic elements like <html>, <head>, and <body>
Viewport meta tag for responsiveness

Next, integrate Bootstrap CSS and JavaScript:

<link href="css/bootstrap.min.css" rel="stylesheet">
<script src="js/bootstrap.min.js"></script>

With these files added, you're ready to leverage Bootstrap's features.

Pro Tip: Ensure your css/bootstrap.min.css and js/bootstrap.min.js files are correctly linked to access Bootstrap's styling and interactive components.

HTTP Status Code 501 - Not Implemented

2013-03-25T11:53:00.002+05:30

The server either does not recognize the request method, or it lacks the ability to fulfill the request.

Why it occurs

The error occurs when the Web server does not understand or support the HTTP method found in the HTTP data stream sent by the client. The method should be one of GET, OPTIONS, HEAD, POST, PUT, DELETE, TRACE, or CONNECT as defined by the HTTP protocol.

If the method is valid but not supported by the Web server, upgrading the server might resolve the issue.

Fixing the 501 error code

Clients should specify a valid request type. If the Web server continues to respond incorrectly, consider upgrading the server.

If you're registered with 100pulse, you'll receive alerts via email or SMS when a 501 status code error occurs.

Using Ajax to Query MySQL

2012-12-21T00:28:00.005+05:30

Using Ajax to Query MySQL

Creating the MySQL Table:

CREATE TABLE `ajax_example` (
  `name` varchar(50) NOT NULL,
  `age` int(11) NOT NULL,
  `sex` varchar(1) NOT NULL,
  `wpm` int(11) NOT NULL,
  PRIMARY KEY  (`name`)
);

Inserting Data into the Table:

INSERT INTO `ajax_example` VALUES ('Jerry', 120, 'm', 20);
INSERT INTO `ajax_example` VALUES ('Regis', 75, 'm', 44);
INSERT INTO `ajax_example` VALUES ('Frank', 45, 'm', 87);
INSERT INTO `ajax_example` VALUES ('Jill', 22, 'f', 72);
INSERT INTO `ajax_example` VALUES ('Tracy', 27, 'f', 0);
INSERT INTO `ajax_example` VALUES ('Julie', 35, 'f', 90);

Client Side HTML File (ajax.html):

<!DOCTYPE html>
<html>
<head>
  <title>Ajax Example</title>
  <script>
    function ajaxFunction() {
      var ajaxRequest;
      try {
        ajaxRequest = new XMLHttpRequest();
      } catch (e) {
        try {
          ajaxRequest = new ActiveXObject("Msxml2.XMLHTTP");
        } catch (e) {
          try {
            ajaxRequest = new ActiveXObject("Microsoft.XMLHTTP");
          } catch (e) {
            alert("Your browser broke!");
            return false;
          }
        }
      }
      
      ajaxRequest.onreadystatechange = function() {
        if (ajaxRequest.readyState == 4) {
          var ajaxDisplay = document.getElementById('ajaxDiv');
          ajaxDisplay.innerHTML = ajaxRequest.responseText;
        }
      }
      
      var age = document.getElementById('age').value;
      var wpm = document.getElementById('wpm').value;
      var sex = document.getElementById('sex').value;
      var queryString = "?age=" + age + "&wpm=" + wpm + "&sex=" + sex;
      
      ajaxRequest.open("GET", "ajax-example.php" + queryString, true);
      ajaxRequest.send(null);
    }
  </script>
</head>
<body>
  <form name='myForm'>
    Max Age: <input type='text' id='age' /> <br />
    Max WPM: <input type='text' id='wpm' /> <br />
    Sex: <select id='sex'>
      <option value="m">m</option>
      <option value="f">f</option>
    </select>
    <input type='button' onclick='ajaxFunction()' value='Query MySQL'/>
  </form>
  
  <div id='ajaxDiv'>Your result will display here</div>
</body>
</html>

Using JavaScript Image Map

2012-12-21T00:25:00.002+05:30

JavaScript can be used to create client-side image maps, which are defined using the <map> and <area> tags in conjunction with the usemap attribute of the <img /> tag.

The <map> element acts as a container for defining clickable hotspots within an image. Each <area> tag specifies a shape and coordinates for the hotspot.

Below is an example demonstrating how to use an image map with JavaScript to display different messages when hovering over specific areas of an image:

<html>
<head>
<title>Using JavaScript Image Map</title>
<script type="text/javascript">
function showTutorial(name) {
  document.myform.stage.value = name;
}
</script>
</head>
<body>
<form name="myform">
  <input type="text" name="stage" size="20" />
</form>

<img src="/images/usemap.gif" alt="HTML Map" 
     border="0" usemap="#tutorials"/>

<map name="tutorials">
  <area shape="poly" coords="74,0,113,29,98,72,52,72,38,27"
        href="/perl/index.htm" alt="Perl Tutorial"
        target="_self" 
        onMouseOver="showTutorial('perl')" 
        onMouseOut="showTutorial('')"/>

  <area shape="rect" coords="22,83,126,125"
        href="/html/index.htm" alt="HTML Tutorial" 
        target="_self" 
        onMouseOver="showTutorial('html')" 
        onMouseOut="showTutorial('')"/>

  <area shape="circle" coords="73,168,32"
        href="/php/index.htm" alt="PHP Tutorial"
        target="_self" 
        onMouseOver="showTutorial('php')" 
        onMouseOut="showTutorial('')"/>
</map>
</body>
</html>

Page Redirection Examples - Learn How to Redirect Web Pages

2012-12-21T00:22:00.004+05:30

Page redirection is essential for directing users from one URL to another. Learn how to implement different types of redirects using JavaScript:

Why Use Page Redirection?

Migrating to a new domain without losing traffic.
Routing users based on browser types or geographical locations.
Maintaining SEO when restructuring URLs.

Examples of Page Redirection

Example 1: Instant Redirection

Redirect users immediately:

<script type="text/javascript">
window.location = "http://www.newlocation.com";
</script>

Example 2: Delayed Redirection with Message

Display a message and redirect after a delay:

<script type="text/javascript">
function Redirect() {
  window.location = "http://www.newlocation.com";
}

document.write("Redirecting in 10 seconds...");
setTimeout('Redirect()', 10000);
</script>

Example 3: Redirect Based on Browser Type

Redirect users based on their browser type:

<script type="text/javascript">
var browserName = navigator.appName; 
if (browserName == "Netscape") {
  window.location = "http://www.location.com/ns.htm";
} else if (browserName == "Microsoft Internet Explorer") {
  window.location = "http://www.location.com/ie.htm";
} else {
  window.location = "http://www.location.com/other.htm";
}
</script>

Printing Web Pages with JavaScript - Learn How to Implement Print Functionality

2012-12-21T00:17:00.003+05:30

Implementing printing functionality on web pages using JavaScript's window.print() function allows users to print the current page directly from the browser.

Implementing Print Functionality

To enable printing, simply use a button with an onclick event:

<input type="button" value="Print" onclick="window.print()" />

This button, when clicked, triggers the browser's print dialog.

Making a Page Printer-Friendly

A printer-friendly page is optimized for printing, usually with minimal graphics and ads:

Create a separate printer-friendly version of the page without unnecessary elements.
Alternatively, mark printable content with HTML comments like  and , and use server-side scripts to generate a printable version.

Our site follows these practices to provide a better printing experience for visitors.

Alternative Printing Method

If no print button is available, users can use the browser's standard toolbar:

File → Print → Click OK.

Client-Side Form Validation with JavaScript

2012-12-21T00:06:00.005+05:30

In traditional web forms, validation occurred on the server after submission, leading to delays and server load. JavaScript allows for client-side form validation, checking data before it's sent to the server.

Basic Form Validation

Basic validation ensures required fields are filled and formats are correct:

<form action="/cgi-bin/test.cgi" name="myForm" onsubmit="return validate()">
  <input type="text" name="Name" />
  <input type="text" name="EMail" />
  <input type="text" name="Zip" />
  <select name="Country">
    <option value="-1" selected>[choose yours]</option>
    <option value="1">USA</option>
    <option value="2">UK</option>
    <option value="3">INDIA</option>
  </select>
  <input type="submit" value="Submit" />
</form>

<script type="text/javascript">
function validate() {
  if (document.myForm.Name.value == "") {
    alert("Please provide your name!");
    document.myForm.Name.focus();
    return false;
  }
  if (document.myForm.EMail.value == "") {
    alert("Please provide your Email!");
    document.myForm.EMail.focus();
    return false;
  }
  if (document.myForm.Zip.value == "" || isNaN(document.myForm.Zip.value) || document.myForm.Zip.value.length != 5) {
    alert("Please provide a zip in the format #####.");
    document.myForm.Zip.focus();
    return false;
  }
  if (document.myForm.Country.value == "-1") {
    alert("Please provide your country!");
    return false;
  }
  return true;
}
</script>

Data Format Validation

Validate specific data formats like email addresses:

<script type="text/javascript">
function validateEmail() {
  var emailID = document.myForm.EMail.value;
  atpos = emailID.indexOf("@");
  dotpos = emailID.lastIndexOf(".");
  if (atpos < 1 || ( dotpos - atpos < 2 )) {
    alert("Please enter correct email ID")
    document.myForm.EMail.focus();
    return false;
  }
  return true;
}
</script>

Types of Errors and Error Handling in JavaScript

2012-12-21T00:04:00.006+05:30

Errors in programming can be categorized into three types: Syntax Errors, Runtime Errors, and Logical Errors.

Syntax Errors

Syntax errors, also known as parsing errors, occur during compilation or interpretation:

<script type="text/javascript">
window.print(;  // Syntax error: missing closing parenthesis
</script>

When a syntax error occurs in JavaScript, only the affected thread stops, allowing other threads to continue.

Runtime Errors

Runtime errors, or exceptions, occur during script execution:

<script type="text/javascript">
window.printme();  // Runtime error: calling a non-existing function
</script>

Exceptions affect the thread they occur in, but other JavaScript threads can continue normally.

Logical Errors

Logical errors are mistakes in the logic of your script, resulting in unexpected behavior:

These errors are not syntax or runtime errors and depend on business logic.

The try...catch...finally Statement

JavaScript supports exception handling with try...catch...finally blocks:

<script type="text/javascript">
try {
    // Code to run
} catch (e) {
    // Code to handle exception
} finally {
    // Code that always executes
}
</script>

The try block must be followed by either a catch block, a finally block, or both.

Examples

Example demonstrating try...catch to handle a runtime error:

<script type="text/javascript">
function myFunc() {
   var a = 100;
   
   try {
      alert("Value of variable a is : " + a);
      window.printme();  // Trying to call a non-existing function
   } catch (e) {
      alert("Error: " + e);
   }
}
</script>

The throw Statement

The throw statement allows you to create custom exceptions:

<script type="text/javascript">
function myFunc() {
   var a = 100;
   var b = 0;
   
   try {
      if (b == 0) {
         throw("Divide by zero error.");
      } else {
         var c = a / b;
      }
   } catch (e) {
      alert("Error: " + e);
   }
}
</script>

The onerror() Method

The onerror event handler provides information about errors occurring on a page:

<script type="text/javascript">
window.onerror = function(msg, url, line) {
   alert("Message: " + msg);
   alert("URL: " + url);
   alert("Line number: " + line);
}
</script>

It helps in identifying and handling errors that occur during script execution.

Understanding the Difference Between GET and POST Methods in HTTP

2012-09-27T19:20:00.004+05:30

When it comes to web development, understanding the fundamental differences between the GET and POST methods in HTTP is essential. These methods are used to send data between the client and server, but they do so in distinct ways, each with its own advantages and limitations. Let's delve into the key differences between GET and POST methods.

GET Method:

Data Transmission: In the GET method, data is appended to the URL as query parameters. This makes it easily visible in the browser's address bar.
Single Call System: GET requests are simple and involve a single call to the server.
Data Size Limit: The amount of data that can be sent via GET is limited to around 256 characters due to URL length restrictions.
Speed: Data transmission is generally faster with GET requests since the data is sent as part of the URL.
Default Method: Many browsers default to using the GET method for requests.
Security: GET is less secure because the data is exposed in the URL. This makes it unsuitable for sending sensitive information like passwords.
Bookmarking: URLs containing GET parameters can be bookmarked, allowing users to save and revisit specific states of a webpage.
Server Logging: Servers can easily log all actions and requests made using the GET method.
Query String Length: Despite server logs, only up to 255 characters can typically be used in a query string.
Form Variables: GET can only store up to 18 form variables.

POST Method:

Data Transmission: Data is not appended to the URL. Instead, it is sent in the body of the request.
Two Call System: POST involves a two-step process: one to send the data and another to receive the response.
Data Size Limit: There is no limit to the amount of data that can be sent using POST. It can handle large volumes of data.
Speed: Data transmission is comparatively slower with POST requests because the data is included in the body of the request.
Default Method: POST is not the default method and must be explicitly specified.
Bookmarking: Pages using POST cannot be bookmarked in the same way as GET requests.
Data Transmission: POST allows for the transmission of unlimited data as query strings.
Security: POST is more secure than GET as data is not visible in the URL, making it suitable for sensitive information.
Form Contents: POST form contents are passed to the script as an input file, allowing for the handling of complex data.

How To Optimize Your Site With GZIP Compression

2012-09-17T11:25:00.000+05:30

Compression is a simple, effective way to save bandwidth and speed up your site. I hesitated when recommending gzip compression when speeding up your javascript because of problems in older browsers.
But it's the 21st century. Most of my traffic comes from modern browsers, and quite frankly, most of my users are fairly tech-savvy. I don't want to slow everyone else down because somebody is chugging along on IE 4.0 on Windows 95. Google and Yahoo use gzip compression. A modern browser is needed to enjoy modern web content and modern web speed -- so gzip encoding it is. Here's how to set it up.

Wait, wait, wait: Why are we doing this?

Before we start I should explain what content encoding is. When you request a file like http://www.yahoo.com/index.html, your browser talks to a web server. The conversation goes a little like this:

1. Browser: Hey, GET me /index.html
2. Server: Ok, let me see if index.html is lying around...
3. Server: Found it! Here's your response code (200 OK) and I'm sending the file.
4. Browser: 100KB? Ouch... waiting, waiting... ok, it's loaded.
Of course, the actual headers and protocols are much more formal (monitor them with Live HTTP Headers if you're so inclined).
But it worked, and you got your file.

So what's the problem?

Well, the system works, but it's not that efficient. 100KB is a lot of text, and frankly, HTML is redundant. Every <html>, <table> and <div> tag has a closing tag that's almost the same. Words are repeated throughout the document. Any way you slice it, HTML (and its beefy cousin, XML) is not lean.
And what's the plan when a file's too big? Zip it!
If we could send a .zip file to the browser (index.html.zip) instead of plain old index.html, we'd save on bandwidth and download time. The browser could download the zipped file, extract it, and then show it to user, who's in a good mood because the page loaded quickly. The browser-server conversation might look like this:

1. Browser: Hey, can I GET index.html? I'll take a compressed version if you've got it.
2. Server: Let me find the file... yep, it's here. And you'll take a compressed version? Awesome.
3. Server: Ok, I've found index.html (200 OK), am zipping it and sending it over.
4. Browser: Great! It's only 10KB. I'll unzip it and show the user.
The formula is simple: Smaller file = faster download = happy user.
Don't believe me? The HTML portion of the yahoo home page goes from 101kb to 15kb after compression:

The (not so) hairy details

The tricky part of this exchange is the browser and server knowing it's ok to send a zipped file over. The agreement has two parts

The browser sends a header telling the server it accepts compressed content (gzip and deflate are two compression schemes): Accept-Encoding: gzip, deflate

The server sends a response if the content is actually compressed: Content-Encoding: gzip

If the server doesn't send the content-encoding response header, it means the file is not compressed (the default on many servers). The "Accept-encoding" header is just a request by the browser, not a demand. If the server doesn't want to send back compressed content, the browser has to make do with the heavy regular version.

Setting up the server

The "good news" is that we can't control the browser. It either sends the Accept-encoding: gzip, deflate header or it doesn't.
Our job is to configure the server so it returns zipped content if the browser can handle it, saving bandwidth for everyone (and giving us a happy user).
For IIS, enable compression in the settings.
In Apache, enabling output compression is fairly straightforward. Add the following to your .htaccess file:


# compress text, html, javascript, css, xml:
AddOutputFilterByType DEFLATE text/plain
AddOutputFilterByType DEFLATE text/html
AddOutputFilterByType DEFLATE text/xml
AddOutputFilterByType DEFLATE text/css
AddOutputFilterByType DEFLATE application/xml
AddOutputFilterByType DEFLATE application/xhtml+xml
AddOutputFilterByType DEFLATE application/rss+xml
AddOutputFilterByType DEFLATE application/javascript
AddOutputFilterByType DEFLATE application/x-javascript

# Or, compress certain file types by extension:
<files *.html>
SetOutputFilter DEFLATE
</files>

Apache actually has two compression options:

mod_deflate is easier to set up and is standard.
mod_gzip seems more powerful: you can pre-compress content.

Deflate is quick and works, so I use it; use mod_gzip if that floats your boat. In either case, Apache checks if the browser sent the "Accept-encoding" header and returns the compressed or regular version of the file. However, some older browsers may have trouble (more below) and there are special directives you can add to correct this.
If you can't change your .htaccess file, you can use PHP to return compressed content. Give your HTML file a .php extension and add this code to the top:
In PHP:
<?php if (substr_count($_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip')) ob_start("ob_gzhandler"); else ob_start(); ?>
We check the "Accept-encoding" header and return a gzipped version of the file (otherwise the regular version). This is almost like building your own webserver (what fun!). But really, try to use Apache to compress your output if you can help it. You don't want to monkey with your files.

Verify Your Compression

Once you've configured your server, check to make sure you're actually serving up compressed content.

Online: Use the online gzip test to check whether your page is compressed.
In your browser: Use Web Developer Toolbar > Information > View Document Size (like I did for Yahoo, above) to see whether the page is compressed.
View the headers: Use Live HTTP Headers to examine the response. Look for a line that says "Content-encoding: gzip".

Be prepared to marvel at the results. The instacalc homepage shrunk from 36k to 10k, a 75% reduction in size.

Try Some Examples

I've set up some pages and a downloadable example:

index.html - No explicit compression (on this server, I am using compression by default ).
index.htm - Explicitly compressed with Apache .htaccess using *.htm as a rule
index.php - Explicitly compressed using the PHP header

Feel free to download the files, put them on your server and tweak the settings.

Caveats

As exciting as it may appear, HTTP Compression isn't all fun and games. Here's what to watch out for:

Older browsers: Yes, some browsers still may have trouble with compressed content (they say they can accept it, but really they can't). If your site absolutely must work with Netscape 1.0 on Windows 95, you may not want to use HTTP Compression. Apache mod_deflate has some rules to avoid compression for older browsers.
Already-compressed content: Most images, music and videos are already compressed. Don't waste time compressing them again. In fact, you probably only need to compress the "big 3" (HTML, CSS and Javascript).
CPU-load: Compressing content on-the-fly uses CPU time and saves bandwidth. Usually this is a great tradeoff given the speed of compression. There are ways to pre-compress static content and send over the compressed versions. This requires more configuration; even if it's not possible, compressing output may still be a net win. Using CPU cycles for a faster user experience is well worth it, given the short attention spans on the web.

Enabling compression is one of the fastest ways to improve your site's performance. Go forth, set it up, and let your users enjoy the benefits.

Life cycle of Servlet

2012-09-15T16:54:00.001+05:30

The life cycle of a servlet can be categorized into four parts:

Loading and Inatantiation: The servlet container loads the servlet during startup or when the first request is made. The loading of the servlet depends on the attribute <load-on-startup> of web.xml file. If the attribute <load-on-startup> has a positive value then the servlet is load with loading of the container otherwise it load when the first request comes for service. After loading of the servlet, the container creates the instances of the servlet.
Initialization: After creating the instances, the servlet container calls the init() method and passes the servlet initialization parameters to the init() method. The init() must be called by the servlet container before the servlet can service any request. The initialization parameters persist untill the servlet is destroyed. The init() method is called only once throughout the life cycle of the servlet.

The servlet will be available for service if it is loaded successfully otherwise the servlet container unloads the servlet.
Servicing the Request: After successfully completing the initialization process, the servlet will be available for service. Servlet creates seperate threads for each request. The sevlet container calls the service() method for servicing any request. The service() method determines the kind of request and calls the appropriate method (doGet() or doPost()) for handling the request and sends response to the client using the methods of the response object.
Destroying the Servlet: If the servlet is no longer needed for servicing any request, the servlet container calls the destroy() method . Like the init() method this method is also called only once throughout the life cycle of the servlet. Calling the destroy() method indicates to the servlet container not to sent the any request for service and the servlet releases all the resources associated with it. Java Virtual Machine claims for the memory associated with the resources for garbage collection.

Methods of Servlets

2012-09-15T16:52:00.001+05:30

A Generic servlet contains the following five methods:

init()

public void init(ServletConfig config) throws ServletException

The init() method is called only once by the servlet container throughout the life of a servlet. By this init() method the servlet get to know that it has been placed into service.

The servlet cannot be put into the service if

The init() method does not return within a fix time set by the web server.
It throws a ServletException

Parameters - The init() method takes a ServletConfig object that contains the initialization parameters and servlet's configuration and throws a ServletException if an exception has occurred.

service()

public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException

Once the servlet starts getting the requests, the service() method is called by the servlet container to respond. The servlet services the client's request with the help of two objects. These two objectsjavax.servlet.ServletRequest and javax.servlet.ServletResponse are passed by the servlet container.

The status code of the response always should be set for a servlet that throws or sends an error.

Parameters - The service() method takes the ServletRequest object that contains the client's request and the object ServletResponse contains the servlet's response. The service() method throwsServletException and IOExceptions exception.

getServletConfig()

public ServletConfig getServletConfig()

This method contains parameters for initialization and startup of the servlet and returns a ServletConfig object. This object is then passed to the init method. When this interface is implemented then it storesthe ServletConfig object in order to return it. It is done by the generic class which implements this inetrface.

Returns - the ServletConfig object

getServletInfo()

public String getServletInfo()

The information about the servlet is returned by this method like version, author etc. This method returns a string which should be in the form of plain text and not any kind of markup.

Returns - a string that contains the information about the servlet

destroy()

public void destroy()

This method is called when we need to close the servlet. That is before removing a servlet instance from service, the servlet container calls the destroy() method. Once the servlet container calls the destroy() method, no service methods will be then called . That is after the exit of all the threads running in the servlet, the destroy() method is called. Hence, the servlet gets a chance to clean up all the resources like memory, threads etc which are being held.

Servlet Container

2012-09-15T16:51:00.001+05:30

A servlet container is nothing but a compiled, executable program. The main function of the container is to load, initialize and execute servlets. The servlet container is the official Reference Implementation for the Java Servlet and JavaServer Pages technologies. The Java Servlet and JavaServer Pages specifications are developed by Sun under the Java Community Process.

A container handles large number of requests as it can hold many active servlets, listeners etc. It is interesting to note here that the container and the objects in a container are multithreaded. So each object must be thread safe in a container as the multiple requests are being handled by the container due to the entrance of more than one thread to an object at a time.

Note : A Servlet container may run stand alone i.e. without a web server or even on another host.

We can categorize the servlet containers as:

I. A simple servlet container is not fully functional and therefore it can only run very simple servlets and does the following :

Wait for HTTP request.
Construct a ServletRequest object and a ServletResponse object.
If the request is for a static resource, invoke the process method of theStaticResourceProcessor instance, passing the ServletRequest andServletResponse objects.
If the request is for a servlet, load the servlet class and invoke its service method, passing theServletRequest and ServletResponse objects. Note that in this servlet container, the servlet class is loaded every time the servlet is requested.

II. A fully functional servlet container additionally does the following for each HTTP request for a servlet:

When the servlet is called for the first time, load the servlet class and call its init method (once only).
For each request, construct an instance of javax.servlet.ServletRequest and an instance of javax.servlet.ServletResponse.
Invoke the servlet's service method, passing the ServletRequest and ServletResponseobjects.
When the servlet class is shut down, call the servlet's destroy method and unload the servlet class.

Now lets see what a servlet container does for each HTTP request for a servlet, in general :

The servlet container loads the servlet class and calls the init method of the servlet as soon as the servlet is called for the first time.
Then this container makes an instance of javax.servlet.ServletRequest andjavax.servlet.ServletResponse for each request.
Then it passes the ServletRequest and ServletResponse objects by invoking the servlet'sservice method.
Finally, it calls the destroy method and unload the servlet class when the servlet class is to be shut down.

What is Java Servlets?

2012-09-15T16:45:00.000+05:30

Servlets are server side components that provide a powerful mechanism for developing server side programs. Servlets provide component-based, platform-independent methods for building Web-based applications, without the performance limitations of CGI programs. Unlike proprietary server extension mechanisms (such as the Netscape Server API or Apache modules), servlets are server as well as platform-independent.

This leaves you free to select a "best of breed" strategy for your servers, platforms, and tools. Using servlets web developers can create fast and efficient server side application which can run on any servlet enabled web server. Servlets run entirely inside the Java Virtual Machine. Since the Servlet runs at server side so it does not checks the browser for compatibility. Servlets can access the entire family of Java APIs, including the JDBC API to access enterprise databases.

Servlets can also access a library of HTTP-specific calls, receive all the benefits of the mature java language including portability, performance, reusability, and crash protection. Today servlets are the popular choice for building interactive web applications. Third-party servlet containers are available for Apache Web Server, Microsoft IIS, and others. Servlet containers are usually the components of web and application servers, such as BEA WebLogic Application Server, IBM WebSphere, Sun Java System Web Server, Sun Java System Application Server and others.

Servlets are not designed for a specific protocols. It is different thing that they are most commonly used with the HTTP protocols Servlets uses the classes in the java packages javax.servlet and javax.servlet.http. Servlets provides a way of creating the sophisticated server side extensions in a server as they follow the standard framework and use the highly portable java language.

HTTP Servlet typically used to:

- Provide dynamic content like getting the results of a database query and returning to the client.
- Process and/or store the data submitted by the HTML.
- Manage information about the state of a stateless HTTP.
- e.g. an online shopping car manages request for multiple concurrent customers.

Table to jqGrid

2012-04-26T02:47:00.001+05:30

In order to use this module you should mark the Table to Grid (in Other modules) when you download the grid.

Calling Convention:

tableToGrid(selector, options)

This is function and not a method

where

selector(string) can be either the table's class or id
options is array with grid options

The html table should have the following structure:

<table class="mytable"> (or <table id="mytable">) 
  <tr> 
     <th> header 1 </th> 
     <th> header 2 </th> 
     ... 
  </tr> 
  <tbody> 
    <tr> 
      <td> data 1 </td> 
      <td> data 1 </td> 
      ... 
    </tr> 
    <tr> 
      ... 
    </tr> 
    .... 
  </tbody> 
<table>