Introduction
Velocity is a template engine. Using Java classes, you can inject objects into template engine and use those injected objects in velocity template (.vm) files.

•  It can be used in desktop applications, web applications and other areas where a structured text or code is required.
• It can be used as a powerful code generator. Dynamic codes are created by velocity injected objects.
• It can access all public attribute and methods of given object.
•  It has an easy and clear syntax.
• You can define user interfaces (HTML, JSP etc.) dynamically and developers and designers can work seperately. So, MVC pattern can be used too.

Here is an example velocity template file helloWorld.vm:

Hello $param

And below is an example Java file HelloWorld.java that uses the template:

import org.apache.velocity.app.VelocityEngine;

import org.apache.velocity.Template;

import org.apache.velocity.VelocityContext;

import java.io.StringWriter;

public class HelloWorld

{

    public static void main( String[] args ) throws Exception

    {

        /*  first, get and initialize an engine  */

        VelocityEngine engine = new VelocityEngine();

        engine.init();

        Template template = engine.getTemplate( "helloWorld.vm" );

        VelocityContext context = new VelocityContext();

        context.put("param", "World");

        StringWriter writer = new StringWriter();

        template.merge( context, writer );

        System.out.println( writer.toString() );    

    }

}

Console Result: Hello World

In the code Velocity engine is created, initialized, velocity tamplate file template is taken, required parameters are put into context, and at last the string is written to the screen.

Commands

Velocity also has a built-in VTL (Velocity Template Language) syntax that has following statements:

VTL Tags

Escape Tool

Because of the VTL is a template language, string operations are required widely. For that case, some escaping methods are supported for java, javascript, html, xml, sql and some character renderings exist: 

(For more detail http://velocity.apache.org/tools/devel/generic/EscapeTool.html)

For example,
$val = “Stop!”
$esc.java($java) 
produces \”Stop!\”
or
${esc.d} produces $ output.
${esc.h} produces # output.

1. Always use source control system even if the project has only one developer. By doing that, you don't lose some or whole code immediately, can share same source file by multiple person and can take the whole advantage of coding histories. 
2. Follow coding standards and check that standard with automized tools.
3. Be consistent. If you do operations in a specific way, do that kind of operations in the same way (e.g. defining variable/method/class names, paranthesis usage etc.).
4. More code does not mean better code. Keep it simple and reduce complexity.
5. Don't use magic numbers and strings directly in the code. Use constants. This method provides more modularity and understandability.
6. Don't use comment lines to delete code, just delete. Version controling system will help you if deleted code is required.
7. Delete unused methods and classes. Version controling system will help you if deleted code is required.
8. Catch specific exceptions instead of highest level class 'Exception'. This will provide understandability and more performance.
9. Use understandable and long names for variables. Loop variable names can be i, j, k, index etc., local variable names must be longer than loop variables, parameter names must be longer than local variables and static variable names must be longer than parameters;  proportional with scope size.
10. Package related classes (that changed together and/or used together) together.
11. Use understandable comments. Bad comment is worse than no comment.
12. Use positive conditionals. Readability of positive conditionals are better than negative ones.
13. Use dependency injection to manage too many singletons.
14. Use exceptions only for catching exceptions, not for control flow. Think as required and perform control flow with control statements/conditionals.
15. Don't use so many arguments with methods. Keep the number at most 8-10. If more is required, review your design.
16. Don't use method alternatives with boolean flag variables (public void someMethod(bool flag)). Write more than one method for each flag condition.  
17. Method names must include "what is done by this method" information.
18. Think twice before defining a method as static and be sure if you really need to. Static methods are harder to manage.
19. Avoid using methods with reference parameters. Use multi attributed object parameters instead.
20. Number of interface methods must be minimized to decrease coupling/dependency.