
About 7 years ago I wrote about [my Git Workflow](https://veerasundar.com/blog/git-tutorial-my-git-work-flow/). I just happened to read that article now and realised "Hey, that's not how I use Git anymore!?". Of course, when I wrote that post, I was just getting started with Git. But now, the post is so outdated that only the "90s kids remember it anymore"! 🤣

Anyway, Long story short: I decided write again about my Git workflow.

Let's start:

## 1. Cloning / Creating a Git repo

```text
$ git clone git@github.com:vraa/blog.git
$ cd blog
```

![Cloning a git repo](https://i.imgur.com/9VKXisd.png)

The first step is to get a local Git repo going. If I am starting a new project myself, I just needed to do `git init` on my project directory. But at work, it is usually cloning my team's existing repo.

## 2. Making changes and branching

```text
$ git checkout -b vraa-master-feature origin/master
```

![Creating branches in Git](https://i.imgur.com/OsCa0dA.png)

Before I start working on my local repo, I always create a separate branch for my work. Branches are cheap in Git. So, I create as many branches as I need.

I follow this naming convention: `[my-short-name]-[parent-branch-name]-[bug/feature-id]`. This convention helps me in quickly identifying / distinguishing my branch or my pull request from the sea of pull requests.

## 3. Pulling in changes

```shell
$ git pull --rebase
```

![Git rebase](https://i.imgur.com/ZMcnyQ1.png)

Often, even before my changes are committed / pushed, the remote repository is always getting updated with other changes.  So, it is vital to bring in those changes as soon as possible, to avoid creating merge conflicts later.

> Note: if my local changes are not yet pushed, then I tend to use `rebase` option instead of a merge. This helps me to keep my branch history clean. But, use it with caution if you have pushed your branch to a remote repo, as `rebase` rewrites commit history, you will end up with a nightmarish merge conflicts.

## 4. Stashing my local changes

```shell
$ git stash
$ git pull
$ git stash pop
```

![Stashing changes in Git](https://i.imgur.com/pjdoOyu.png)

Sometimes, when I try to pull remote changes and it overwrite my local changes, git won't let me to pull. If I am in middle of the work and not yet ready to commit the changes, I stash my local changes, so that I can safely pull in the remote changes.

After applying the stashed files, if there are any merge conflicts, then I will have to deal with it.

## 5. Reordering and squashing my commits

```text
$ git rebase -i 8e35004e04f352b20eda0eb0a4d46574d8fba216
// re order and combine multiple commits into single one
```

![Squashing multiple commits](https://i.imgur.com/CQYWReL.png)

During development, I usually commit as many times as possible. This helps me to go back in history if something breaks. But this also introduces lots of mid work / partial commits. I usually clean my working history by squashing multiple commits into a single commit.

Be aware that this rewrites history. So, never do this if you have already pushed your changes to remote and other people have got your changes.

## 6. Pushing my changes

```text
$ git push origin
```

![Push changes](https://i.imgur.com/TaCjP4Z.png)

And finally it's time to deliver my changes and break the build.. wait.. no... just deliver the changes. Once my changes are delivered and merged, I usually remove the branch locally and remotely. This helps to keep the branch count at check.
```


My Git Workflow


In JavaScript, when you define an object, you can attach it's functions in two different ways.

1. Inside object's constructor function, using `this.func = function(){...}`
2. Using `prototype`. i.e. `Obj.prototype.func = function() {...}`.

In both approaches, the function `func()` will be accessible to all the instances of your object.

But which one is the best way to use?

In short: Use `prototype` - which is effective for _most_ cases. If your objective is to share common functionality between your object instances, then `prototype` is the way to go.

## 1. Modifying the common functionality is easy with Prototype

When you use `prototype` to attach common functions to objects, it is easy to modify the common logic even after the instances are created. The old and new objects will use the updated code. But this may not be possible if you attach the common code to each object instance, using `this.func()`.

Let's see this with an example.

```javascript

function Parent(gender){
  this.gender = gender;

  // attach the common function to each object instance.
  this.yellAtChild = function(){
    console.log('Somebody gonna get a hurt real bad!');
  }
}

// Let's create dad and mom and start yelling at kids.
var dad = new Parent('male');
var mom = new Parent('female');
dad.yellAtChild(); // Somebody gonna get a hurt real bad!
mom.yellAtChild(); // Somebody gonna get a hurt real bad!

// but, Russell has decide to sue you if you use his catch phrase.
// Let's try to tell our already created dad & mon to use different phrase.

// ERROR: Not possible to do this way.
Parent.yellAtChild = function() { .... }

// You need to override the `yellAtChild` method for each object instance.
dad.yellAtChild = function(){
  console.log('Shut up!');
};
mom.yellAtChild = function(){
  console.log('Go to bed!');
}
dad.yellAtChild(); // Shut up!
mom.yellAtChild(); // Go to bed!

```

As you can see, if you decide to change the common logic, you can not easily update the object methods since they are already created. You need to modify each and every instance of that object which is tedious.

Let's see the same example, but this time with `prototype`.

```javascript

function Parent(gender){
  this.gender = gender;
}

// Attach the common function to prototype.
Parent.prototype.yellAtChild = function(){
  console.log('Somebody gonna get a hurt real bad!');
};

// Let's create dad and mom and start yelling at kids.
var dad = new Parent('male');
var mom = new Parent('female');
dad.yellAtChild(); // Somebody gonna get a hurt real bad!
mom.yellAtChild(); // Somebody gonna get a hurt real bad!

// but, Russell has decide to sue you if you use his catch phrase.
// Simple: Just modify the function at Parent.prototype.

Parent.prototype.yellAtChild = function(){
  console.log('You are grounded.');
};

dad.yellAtChild(); // You are grounded
mom.yellAtChild(); // You are grounded

```

So, all the changes that you make to functions in `prototype` will reflect in all the instances of that object. Even for the new objects that you create will use the modifed method.

## 2. Prototype is fast and memory efficient.

When you attach methods to object instances, then each instance will have it's own copy of the method. This involves the system processing time and the memory.

But, when you attach the method to object's `prototype`, then only one version of the method exists. This doesn't need as much processing time and memory when compared to the above approach.

Let's see this with an example.

```javascript
var Parent = function(){
  this.yellAtKid = function(){
    console.log('Somebody gonna get a hurt real bad!');
  };
};
console.profile('Object Methods');
var dads = [];
for(var i=0; i<=10000000; i++){
  dads.push(new Parent());
}
console.profileEnd(); // 4903.267ms
```

When I profiled the above code in Firefox / Mac, the `populate()` method took about **4903.267ms** to execute. If I changed method attachment to `prototype` instead, like below:

```javascript
var Parent = function(){
};

Parent.prototype.yellAtKid = function(){
  console.log('Somebody gonna get a hurt real bad!');
};

console.profile('Prototype Methods');
var dads = [];
for(var i=0; i<=10000000; i++){
  dads.push(new Parent());
}
console.profileEnd(); // 3271.413ms
```

This time, the `populate()` method took only **3271.413ms** seconds. So, about **1.5 seconds** we save, just by reattaching the methods to `prototype`,

I hope that explains why `prototype` is best way to share common logic between your javascript objects.


Javascript Prototype methods vs Object methods


It is often a requirement that you need to connect to a server through [HTTP][1] from your android application. When you use servlets/html, making such requests are a [no-brainer][2]. But, in Android it needs some searching before implementing such functions.

[1]: https://veerasundar.com/blog/hosting-java-applications-in-the-web "Hosting Java applications in the web"
[2]: https://veerasundar.com/blog/implementing-ajax-in-java-web-application-using-jquery "Implementing Ajax in Java web application using JQuery"

Here's some sample code snippets that explains how you can make GET and POST requests from your android application.

## Enable Internet permission for your android application:

Before making any use of internet in your android application, you should enable the internet permission for your application. To do this, open the *AndroidManifest.xml *file and then add the below line:

## HTTP GET request in Android application:

```java
    public static String getHttpResponse(URI uri) {
    	Log.d(APP_TAG, "Going to make a get request");
    	StringBuilder response = new StringBuilder();
    	try {
    		HttpGet get = new HttpGet();
    		get.setURI(uri);
    		DefaultHttpClient httpClient = new DefaultHttpClient();
    		HttpResponse httpResponse = httpClient.execute(get);
    		if (httpResponse.getStatusLine().getStatusCode() == 200) {
    			Log.d("demo", "HTTP Get succeeded");

    			HttpEntity messageEntity = httpResponse.getEntity();
    			InputStream is = messageEntity.getContent();
    			BufferedReader br = new BufferedReader(new InputStreamReader(is));
    			String line;
    			while ((line = br.readLine()) != null) {
    				response.append(line);
    			}
    		}
    	} catch (Exception e) {
    		Log.e("demo", e.getMessage());
    	}
    	Log.d("demo", "Done with HTTP getting");
    	return response.toString();
    }
```

## HTTP POST request in Android application:

A POST request is slightly (well, vastly) different from a GET request (I have seen most developers use there requests interchangeably!). In a POST, we often send some parameters to change state of the objects in server.

In Android too, we have some mechanisms to send HTTP parameters while sending a POST request, which is shown in below code snippet.

```java
    public static String postHttpResponse(URI uri) {
    	Log.d(APP_TAG, "Going to make a post request");
    	StringBuilder response = new StringBuilder();
    	try {
    		HttpPost post = new HttpPost();
    		post.setURI(uri);
    		List params = new ArrayList();
    		params.add(new BasicNameValuePair("paramName", "paramValue"));
    		post.setEntity(new UrlEncodedFormEntity(params));
    		DefaultHttpClient httpClient = new DefaultHttpClient();
    		HttpResponse httpResponse = httpClient.execute(post);
    		if (httpResponse.getStatusLine().getStatusCode() == 200) {
    			Log.d(APP_TAG, "HTTP POST succeeded");
    			HttpEntity messageEntity = httpResponse.getEntity();
    			InputStream is = messageEntity.getContent();
    			BufferedReader br = new BufferedReader(new InputStreamReader(is));
    			String line;
    			while ((line = br.readLine()) != null) {
    				response.append(line);
    			}
    		} else {
    			Log.e(APP_TAG, "HTTP POST status code is not 200");
    		}
    	} catch (Exception e) {
    		Log.e(APP_TAG, e.getMessage());
    	}
    	Log.d(APP_TAG, "Done with HTTP posting");
    	return response.toString();
    }
```

Making GET and POST requests in android application


Lets say that you have pushed your code live and now want to code for a new feature. And, suddenly a bug found in your live code (it happens! a LOT!) which needs an immediate fix from you. Now, you have two different coding tasks in your hand.

1.  Code for your feature - which you can not commit in your main code base, because of some partial work.
2.  At the same time, you can not fix the bug in the main code base and push it to live because of the partial code which could break the builds (and hearts of some tech support guys!).

So, what will you do? **Branch! **Lets create two different branches - one for feature and one for bug-fixes and you can happily code on your branches without fearing that it might break the main code base.\*\*  
\*\*

## Git Branch:

![git branching][1]

[1]: https://veerasundar.com/img/2011/06/git-branch.jpg "git-branch"

Branching is something that every developer often do. When you branch, Git is taking a copy of your main code base and saving it in a different name (imagine the _File -> Save as_). So, the changes you do in your branched code will not affect your main code.

Having said that, lets see how to create new branches in Git. I'm opening my [_helloworld_][2] project again with the clean working directory.

[2]: https://veerasundar.com/blog/git-tutorial-my-git-work-flow "My Git Workflow"

    ~/work/projects/helloworld$ git status
    # On branch master
    nothing to commit (working directory clean)

So, now I'm on the *master *branch which is the **default **branch in Git. I want to create a new feature to add line of text 'Hello India' to my file. For that, lets create a branch _india_.

    ~/work/projects/helloworld$ git branch india
    ~/work/projects/helloworld$ git branch
      india
    * master

There we go! In the first line, I ask Git to _create_ a new branch by giving a branch name _india_. In the second, I ask Git to *list *all the available branches which lists *india *and the default branch _master_. The \* marks denotes the branch you are currently in.

Now you created a new branch. But you are still in the *master *branch. You have to switch to the newly created branch before making any changes. Lets do that.

    ~/work/projects/helloworld$ git checkout india
    Switched to branch 'india'

Now we switched to the* india *branch. you can make your changes and commit as many times as you wish. This will not affect the *master *branch in any way (until your merge your changes back).\*

- ~/work/projects/helloworld$ gedit helloworld.txt
  ~/work/projects/helloworld$ git add helloworld.txt
  ~/work/projects/helloworld$ git status

  # On branch india

  # Changes to be committed:

  # (use "git reset HEAD ..." to unstage)

  #

  # modified: helloworld.txt

  #

  ~/work/projects/helloworld$ git commit -m "modified in india branch"
  [india 2b2fa49] modified in india branch
  1 files changed, 1 insertions( ), 0 deletions(-)

## Merging changes back to main branch:

![git merge][3]

[3]: https://veerasundar.com/img/2011/06/git-merge.jpg "git-merge"

Now it is time to merge your feature code to the main branch. In a simpler words, we are going to do this: **_master = master india_**!

    ~/work/projects/helloworld$ git checkout master
    Switched to branch 'master'
    ~/work/projects/helloworld$ git merge india
    Updating 8f8c6ba..2b2fa49
    Fast-forward
     helloworld.txt |    1
     1 files changed, 1 insertions( ), 0 deletions(-)

As you can see, to merge, first switch back to *master *branch then give the *merge *command with the branch name you want to merge. That simple! If you open the *helloworld.txt *file, you can see the changes made in the *india *branch. Also, you can give the command *git log helloworld.txt *which will display all the commits you made on this files, including the *india *branch changes too.

Life is not always this simple. When you merge, there's a possibility that conflicts could occur. I'll explain how to resolve these conflicts in my next post.


Git tutorial - branching and merging


As I promised on my previous article on [Getting started with Git][1], here is how I use Git in my day to day activities. Rather than explaining with a real project that I'm working (which I can't share!), I'm taking the 'ËœHello World' approach. What I'm going to do is to create a text file that contains the 'hello world' and then going to track it in Git.

[1]: https://veerasundar.com/blog/git-tutorial-getting-started "Git Tutorial - Getting Started"

I assume that you have [installed Git][2] on your machine and you have the PATH environment variable updated with Git's location. Also, I'm going to explain it with a local repository which means that I'll be creating the repository locally instead of cloning it from some remote repository. Let's start.

[2]: http://help.github.com/win-set-up-git/

## 1. Git repository creation

Open a terminal or command prompt and CD to your project directory. Then give the below command.

    c:> cd vraa/projects/helloworld
    C:/vraa/projects/helloworld>git init
    Initialized empty Git repository in C:/vraa/projects/helloworld/.git/

Now what I did was to create a** new local Git repository** to track my hello world project.

## 2. Git configuration - user name and email (one time)

Next thing is to setup a user name and email to be used in all my git commits. This is a one time activity per Git installation.

    C:/vraa/projects/helloworld> git config --global user.name "yourname"
    C:/vraa/projects/helloworld> git config --global user.email "your@mail.com"

## 3. Add a file to Git index and check status

Let's create a simple text file and see what Git feels about this file using **git status** command. Status will tell you the current status of the repository and branch details. And, in Git you don't need to check out anything before you start working on it. Just modify the file directly and then commit the changes later.

    C:/vraa/projects/helloworld> edit helloworld.txt
    C:/vraa/projects/helloworld> git status
    # On branch master
    #
    # Initial commit
    #
    # Untracked files:
    #   (use "git add ..." to include in what will be committed)
    #
    #       helloworld.txt
    nothing added to commit but untracked files present (use "git add" to track)

Ha! Git knows that there's a file but it is not tracking it yet. Well, we'll tell Git to track it (after all that is what Git is for!)

    C:/vraa/projects/helloworld> git add helloworld.txt
    C:/vraa/projects/helloworld> git status
    # On branch master
    #
    # Initial commit
    #
    # Changes to be committed:
    #   (use "git rm --cached ..." to unstage)
    #
    #       new file:   helloworld.txt

Now you can see that the status command tells you the list of files that will be committed. So, when you say **git add [filename]** you are asking the git to keep the file in _git index_ and track the changes. Simple, you are staging this file for commit. Next time when you do a commit all the files that are in index will be committed.

## 4. Let's commit the changes

By committing, you are moving your changes from _index_ to the _local repository_. Unlike Subversion, where a commit means saving code to a central repository, in git even after a commit the code will reside in your local repo. The outside world won't know about your changes, yet. So, you can fearlessly do as many commits as you wish.

    C:/vraa/projects/helloworld> git commit -m "initial commit"
    [master (root-commit) 812befb] initial commit
    warning: CRLF will be replaced by LF in helloworld.txt.
    The file will have its original line endings in your working directory.
     1 files changed, 1 insertions( ), 0 deletions(-)
     create mode 100644 helloworld.txt
    C:/vraa/projects/helloworld> git status
    # On branch master
    nothing to commit (working directory clean)

So, that's how my basic git workflow looks like. Creating a simple and committing and tracking changes using Git. In my [next post][3], I'll explain how I do more changes and differentiate between several file versions.

[3]: https://veerasundar.com/blog/git-tutorial-comparing-files-with-diff


Git Tutorial - My Git work flow


![git logo][1]I was a long time Subversion user then. So, when I got introduced to Git few months back, I was \*\*really\*\* confused. First of all, I couldn't visualize some of the concepts that Git talked about.

[1]: https://veerasundar.com/img/2011/06/git-logo.png "git-logo"

But then, as I started using Git in my day-to-day work, it got much easy to use and understand. Now there isn't a single day (except some of the weekends!) in which I don' t use a single Git command. It became an inseparable tool at my work.

So, just thought of writing my learning as a Git tutorial series to help a bit my fellow developers who want to switch over to Git. Let' start.

## Say Hello to Git

First of all, if you are coming from a Subversion/CVS background - mark my words - **forget everything you learned about version controlling**. Because Git has a completely different approach to version controlling. Lets see how it differs from other systems.

Git is distributed. Which means, when you clone a Git repo, you'll get a your own copy of that repo to work with in your local machine. In Git, you get your own code base, you make changes, commit as many times as you want without the fear of polluting the central repo and once you are confident push the code to central repository.

Before diving too much further, let's look at this awesome diagram which explains the Git workflow (thanks to [osteele.com][2], I have a printout of this pasted at my desk).

[2]: http://osteele.com

![git workflow][3]

[3]: https://veerasundar.com/img/2011/06/git.png "git"

As you can see in the above diagram, in Git, code lives in 4 different places

- **_remote repository _**- think of it as a Github repository or a remote server hosted in your company. As the name suggests, this code base does not live your local machine and You don't talk with remote repository often. Only when you pull a code initially and pushing the changes when you are done with it.
- **\*local repository** - \*when you clone a remote Git repo / or create a new repo, the code base is created here in the local repository. All commits you do will come here first. This lives in your local machine.
- **_index _**- one of the most confusing thing you'll ever hear in Git. This is something like a intermediate place between your working copy of code and your local repository. It's like a _staging area_ for your code. You use it to stage which files you want to track & commit. In my next post about *[My Git workflow][4] *you'll see how index is used. This code base too, lives in your local machine.
- **_workspace _**- it's your working directory where you create/edit/delete your files. This code resides in your local machine.

[4]: https://veerasundar.com/blog/git-tutorial-my-git-work-flow "Git tutorial - my git workflow"

Hope you get the basic concepts of Git. It is very important to understand it well before you start using Git. In my next post, I'll be writing about [my Git workflow][4]. Till then, feel free to [setup your Git environment][5].

[5]: http://help.github.com/win-set-up-git/ "This guide will walk you through the basics and explain a little bit about how everything works along the way."


Git Tutorial - Getting Started


Recently one of my blog reader *Surisetty *send me a question, asking me if it is possible **to write log messages of different levels (info, debug, etc) into different log files**? To answer his question, **yes, it is possible. **We can do this\*\* \*\*by extending the FileAppender class and writing our own logic.

Below is the proof of concept code written to demonstrate this. Before that, you can download the Eclipse project file to run this code in your environment.

[Download the Source code][1]

[1]: http://www.box.net/shared/g3esrz13q4

## To write different log levels in different log files

1.  Create a custom Log4j appender extending _FileAppender._
2.  In that, override the *append() *method and check for the log level before writing a log message. Based on the level, call the *setFile() *method to switch between corresponding log file.
3.  Also, use MDC to store the original log file name mentioned in the _log4j.properties_. This is needed because *setFile() *changes the log file name every time you call it. So, we need to keep a track of the original file name somehow. And, we can use [Log4j MDC][2] for this.

[2]: https://veerasundar.com/blog/log4j-mdc-mapped-diagnostic-context-what-and-why

## Custom Appender: LogLevelFilterFileAppender

```java
    package com.veerasundar.log4j;

    import java.io.File;
    import java.io.IOException;

    import org.apache.log4j.FileAppender;
    import org.apache.log4j.Layout;
    import org.apache.log4j.MDC;
    import org.apache.log4j.spi.ErrorCode;
    import org.apache.log4j.spi.LoggingEvent;

    /**
     * This customized Log4j appender will separate the log messages based on their
     * LEVELS and will write them into separate files. For example, all DEBUG
     * messages will go to a file and all INFO messages will go to a different file.
     *
     * @author Veera Sundar | https://veerasundar.com
     *
     */
    public class LogLevelFilterFileAppender extends FileAppender {

    	private final static String DOT = ".";
    	private final static String HIPHEN = "-";
    	private static final String ORIG_LOG_FILE_NAME = "OrginalLogFileName";

    	public LogLevelFilterFileAppender() {

    	}

    	public LogLevelFilterFileAppender(Layout layout, String fileName,
    			boolean append, boolean bufferedIO, int bufferSize)
    			throws IOException {
    		super(layout, fileName, append, bufferedIO, bufferSize);
    	}

    	public LogLevelFilterFileAppender(Layout layout, String fileName,
    			boolean append) throws IOException {
    		super(layout, fileName, append);
    	}

    	public LogLevelFilterFileAppender(Layout layout, String fileName)
    			throws IOException {
    		super(layout, fileName);
    	}

    	@Override
    	public void activateOptions() {
    		MDC.put(ORIG_LOG_FILE_NAME, fileName);
    		super.activateOptions();
    	}

    	@Override
    	public void append(LoggingEvent event) {
    		try {
    			setFile(appendLevelToFileName((String) MDC.get(ORIG_LOG_FILE_NAME),
    					event.getLevel().toString()), fileAppend, bufferedIO,
    					bufferSize);
    		} catch (IOException ie) {
    			errorHandler
    					.error(
    							"Error occured while setting file for the log level "
    									  event.getLevel(), ie,
    							ErrorCode.FILE_OPEN_FAILURE);
    		}
    		super.append(event);
    	}

    	private String appendLevelToFileName(String oldLogFileName, String level) {
    		if (oldLogFileName != null) {
    			final File logFile = new File(oldLogFileName);
    			String newFileName = "";
    			final String fn = logFile.getName();
    			final int dotIndex = fn.indexOf(DOT);
    			if (dotIndex != -1) {
    				// the file name has an extension. so, insert the level
    				// between the file name and the extension
    				newFileName = fn.substring(0, dotIndex)   HIPHEN   level   DOT
    						  fn.substring(dotIndex   1);
    			} else {
    				// the file name has no extension. So, just append the level
    				// at the end.
    				newFileName = fn   HIPHEN   level;
    			}
    			return logFile.getParent()   File.separator   newFileName;
    		}
    		return null;
    	}
    }
```

## log4j.properties file

```
    log4j.rootLogger = DEBUG, fileout
    log4j.appender.fileout = com.veerasundar.log4j.LogLevelFilterFileAppender
    log4j.appender.fileout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c - %m%n
    log4j.appender.fileout.layout = org.apache.log4j.PatternLayout
    log4j.appender.fileout.File = C:/vraa/temp/logs.log
```

## Let's test our code

```java
    package com.veerasundar.log4j;

    import org.apache.log4j.Logger;

    public class Log4jDemo {

    	private static final Logger logger = Logger.getLogger(Log4jDemo.class);

    	public static void main(String args[]) {
    		logger.debug("This is a debug message");
    		logger.info("This is a information message");
    		logger.warn("This is a warning message");
    		logger.error("This is an error message");
    		logger.fatal("This is a fatal message");
    		logger.debug("This is another debug message");
    		logger.info("This is another information message");
    		logger.warn("This is another warning message");
    		logger.error("This is another error message");
    		logger.fatal("This is another fatal message");
    	}
    }
```


Log4j Tutorial - Writing different log levels in different log files


![Google App Engine on Netbeans][1]If you just started with App engine development, you might be having a feeling that Eclipse is the preferred IDE. And, Google also has offered its [official plug-in][2] to Eclipse IDE alone.

[1]: https://veerasundar.com/img/2011/04/nb.png "Google App Engine on Netbeans"
[2]: http://code.google.com/appengine/docs/java/tools/eclipse.html "It's easy to use the Eclipse development environment to develop your Java App Engine application, just as you can to develop any other servlet-based web application. With the Google Plugin for Eclipse, it's even easier. The plugin lets you create, test and upload App Engine applications from within Eclipse."

But what about the people who are not using Eclipse? Of course, you can always do a command line development but who does that these days!?

For **[Netbeans][3]** users, the plug-in **[nbappengine][4] **brings the Java app engine development to the Netbeans platform. Here's how you can start developing your app engine apps on Netbeans.

[3]: http://netbeans.org/
[4]: http://kenai.com/projects/nbappengine/pages/Home "Plugin enables J2EE development web modules on Google App Engine."

## Installing nbappengine plugin on Netbeans

1.  First thing first: Install the latest Netbeans (6.9 at the time of typing these characters) and open the IDE.
2.  Go to **Tools -> Plugins -> Settings **and click 'Add' button to add the nbappengine update center URL.
3.  Now give a name and the URL of the update center according to your version of Netbeans.
    - **Netbeans 6.9**: http://kenai.com/downloads/nbappengine/NetBeans69/updates.xml
    - **Netbeans 6.8**: http://kenai.com/projects/nbappengine/downloads/download/Latest_NetBeans68/updates.xml
    - **Netbeans 6.7**: http://kenai.com/projects/nbappengine/downloads/download/1.0_NetBeans671/updates.xml
4.  After adding it, now come back to the **'Available Plugins' **tab and do a search for 'Google'. Select all the plug-ins that are related to the App Engine and click install button.

## Configuring App Engine SDK with Netbeans

Now you've installed the nbappengine plugin on your Netbeans IDE.  The coming steps will tell you how you can configure the plugin with the App Engine SDK.

1.  Download the [App Engine SDK][5] for Java and extract the zip contents to your favorite location.
2.  In the Netbeans IDE, go to **Services window **(Ctrl 5 is the shortcut key) and right click on the **Servers **menu and select '**Add Server**'.
3.  Now select the '**Google App Engine' **from the list of servers and in the next screen choose the folder where you extracted your SDK files.
4.  Configure the server properties if you wish to change it and then click '**Finish'**

[5]: http://code.google.com/appengine/downloads.html#Google_App_Engine_SDK_for_Java

## Creating and deploying your first App Engine app on Netbeans

Now its the time to create a brand-new app engine application.

1.  In Netbeans, select '**File -> New Project -> Java Web -> Web application' **and follow the wizard to create the project.
2.  In the '**Server and Settings' **page choose '**Google App Engine' **as your server so that you'll get the app-engine related files (such as appengine-web.xml) pre-created for you.
3.  When you run/debug this application, Netbeans will start the app engine server (Jetty) and will deploy your application there.
4.  To deploy the application to the App Engine server, just right click on the project and choose '**Deploy to Google App Engine'. **it'll prompt you for the Google account credentials. After you provided that info, your app will be uploaded to the cloud.


App Engine Java development on Netbeans


Note: This post is written by/for the Java web developer who is using Google App Engine. Even if you are not an Java developer, but interested, you are welcome to read further.

![google-app-engine-logo][1]

[1]: https://veerasundar.com/img/2011/04/google-app-engine.png "google-app-engine"

When you create a new application in Google App Engine, you'll get a domain name 'yourapp.appspot.com'. But, who'll want to host their app with such a suffix (unless you like it!)?

To improve your app branding, the best thing to do is to host your app in '**www.yourapp.com**'. So, how to do this in App Engine?

There are two ways.

1.  You can buy a new domain name with Google partnered sites (such as GoDaddy).
2.  If you have already bought a domain, you can map that domain to 'yourapp.appspot.com'.

I'm going to explain the second method in this post.

## Steps to host GAE app in your own domain

### 1. Buy Hosting Space and Signup for Google Apps

1.  The first step, obviously, is you should buy a **domain hosting**. You will be adding CNAME entry in the DNS mapping to make things work and some hosting providers wont let you to add CNAME if you just bought only the domain name from them. So, it is good to buy the domain name as well as the hosting space so that you have full control over it.
2.  Then you need to signup for **Google apps** with your domain name. You can get a [free Google Apps version][2] which is pretty much sufficient for a small company/individual. You'll be asked to verify the ownership of your domain. Just follow the steps given there. You'll be also creating a admin account to manage Google Apps.

[2]: https://www.google.com/a/cpanel/domain/new "Free version of Google Apps - Signup page"

### 2. Add your application to Google Apps account

1.  Next, login to and go to the Dashboard of your app and choose '**Application Settings -> Domain Setup -> Add Domain**'.
2.  In the '**Add Domain**' screen, enter your domain name. You'll be asked to login to Google Apps with the admin account which you would have created during the second step. Once you login, your application will be added to your Google Apps account.

### 3. Add 'Ëœwww.yourapp.com' sub-domain mapping to yourapp.appspot.com

1.  Now login to **www.google.com/a/yourapp.com **with your admin account (if you are not logged in already). There you can see you app engine application listed in the Google Apps dashboard. Click on your appspot application.
2.  In the next screen, enter **www** in the text box to add a URL in the form of **www.yourapp.com**. As Google app engine does not support naked domains, you have to map the sub-domain, in our case **www**, to the appspot application. Once you add the URL you'll be given steps to add the CNAME record in your domain. After adding the CNAME record (explained in next steps), you should come back to this page and click complete.

### 4. Using CPanel, add a CNAME entry to ghs.google.com

1.  Now login to your domain admin panel. Since most of the hosting providers support CPanel, i'm giving the steps for CPanel.
2.  Login to **yourapp.com/cpanel **and go to '**Advanced DNS Zone editor' **where you can see the DNS mappings.
3.  Click the 'Edit' link against the **www.yourapp.com **and type '**ghs.google.com**' against the CNAME field. Leave other fields as it is. Save the changes.
4.  Thats it. It will take some time for the DNS propagation to happen. After that you can start accessing your appspot application with the URL **www.yourapp.com**!


Hosting Google App Engine application in your own domain


\*\*In this post, I'm going to explain how you can setup a Java development environment (JDK Eclipse) in Ubuntu. I'm using Ubuntu 10.10, but these steps should be applicable to majority of Ubuntu versions.

Let's start with JDK first.

## Install Sun JDK:

1.  Download the Linux version of latest JDK binary from the [Oracle website][1]. For Java 6, the file name would be: **_jdk-6u22-linux-i586.bin_**
2.  Copy the downloaded JDK file to a directory where you want to install the JDK. I use ***/home//java/*jdk-6u22-linux-i586.bin\*\***
3.  Open terminal window and navigate to the directory where you copied the downloaded file. Then type the command: **\*sudo sh jdk-6u22-linux-i586.bin** \*and press enter.
4.  If it asks for root password, give it and JDK installation will begin. The JDK will be installed on the same directory where the binary is placed.

[1]: http://www.oracle.com/technetwork/java/javase/downloads/index.html "JDK downloads"

That's it. JDK installation is done. But we still have one more step to complete. That is, setting up the _JAVA_HOME_ environment variable.

## Setting up JAVA_HOME environment variable:

1.  Go to Nautilus file browser (_Places -> Home Folder_) and open this file: **_'.bashrc'_**. By default this file is hidden. So, press *Ctrl H *which will show all hidden files and then you can see the *.bashrc *file.
2.  Add the below code snippet at the end of the *.bashrc *file:
    export JAVA_HOME=/home//java/jdk1.6.0_22
    PATH=.:$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH

    **Don't forget to change the path in first line according to where you installed your JDK**

    - That's it. Log off and Log in again for the changes to take effect. To test whether the installation successful, open Terminal and type *java -version *which should show you the currently installed JDK version.

    ## Install Eclipse:

    Installing Eclipse in Ubuntu is pretty simple. Just [download][2] the ZIP file from Eclipse.org and then unzip it. The installation is done. ![;-)][3]

[2]: http://www.eclipse.org/downloads/ "Eclipse downloads"
[3]: https://veerasundar.com/blog/wp-includes/images/smilies/icon_wink.gif


How to setup Java development environment in Ubuntu?

I have already written about the _Spring Aspect Oriented Programming (AOP)_ with the use of simple logging example. But, somehow I felt that the example code was little confusing for the newcomers. So, I decided to write a new Spring AOP example code that explains how to use Spring AOP for profiling method execution time.

## Using Spring AOP to profile method execution time:

The example I chose is very simple: our application has a business class and a business method. We are going to profile how much time does it take to execute the business method. We will use Spring AOP for profiling the execution time. Since, profiling is a best example for _cross cutting concern_, it's a good decision to use Spring AOP for implementing it. I'll explain these in step by step. Meanwhile, you can [download the source code][1](excluding dependent JAR file, for which you can see the download links below).

[1]: http://www.box.net/shared/9nygu7t80t "Download source code for Spring AOP example"

And, here's the library versions I'm using: [Spring 2.5.4][2], JDK 1.6, [Commons-logging-1.0.4][3], [aspectjrt-1.2][4], [aspectjweaver-1.5.3][5].

[2]: http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-2.5.4.zip "Download Spring 2.5.4 JAR"
[3]: http://mirrors.ibiblio.org/pub/mirrors/maven/commons-logging/jars/commons-logging-1.0.4.jar "Download commons logging"
[4]: http://mirrors.ibiblio.org/pub/mirrors/maven/aspectj/jars/aspectjrt-1.2.jar
[5]: http://mirrors.ibiblio.org/pub/mirrors/maven/aspectj/jars/aspectjweaver-1.5.3.jar

## 1. Setting up the project structure:

Launch your preferred IDE (I use Eclipse) and _Create New Java Project_. And then create the file structure as shown below (off course, no need to follow the package naming convention.

![Spring AOP - Project Structure][7]

[7]: https://veerasundar.com/img/2010/01/spring-aop-project-structure.png "spring-aop-project-structure"

You need to download all the JARs that are in _Referenced Libraries_ and add them to the project's class path. You can find these JARs here: [Spring][8], [Commons-logging][9], [aspectjrt][10], [aspectjweaver][11]. Also, please note that the file **Business.java** is an Interface. Other than this, all other java files are plain Classes.

[8]: http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-2.5.4.zip "Download Spring"
[9]: http://mirrors.ibiblio.org/pub/mirrors/maven/commons-logging/jars/commons-logging-1.0.4.jar "Download Commons-logging"
[10]: http://mirrors.ibiblio.org/pub/mirrors/maven/aspectj/jars/aspectjrt-1.2.jar "Download AspectJrt"
[11]: http://mirrors.ibiblio.org/pub/mirrors/maven/aspectj/jars/aspectjweaver-1.5.3.jar "download Aspectjweaver"

## 2. Writing our Business Logic:

We will first write our business logic and then we will add Spring AOP to profile our business methods. Open _Business.java_ interface and copy the below code into it.

```java

    package com.veerasundar.spring.aop;

    public interface Business {
            void doSomeOperation();
    }

```

Now, open the *BusinessImpl.java* and copy the below code into it.

```java

    package com.veerasundar.spring.aop;

    public class BusinessImpl implements Business {

            public void doSomeOperation() {
                    System.out.println("I do what I do best, i.e sleep.");
                    try {
                            Thread.sleep(2000);
                    } catch (InterruptedException e) {
                            System.out.println("How dare you to wake me up?");
                    }
                    System.out.println("Done with sleeping.");
            }

    }

```

I guess this code is self explanatory. Our business method just sleeps for 2 seconds (good business, isn't it!?) and then write some text on the console.

## 3. Writing a Spring Aspect to profile business method:

Lets write a Aspect which will profile our business method. I'm gonna use **@Around** advice (Lost in the jargons? [Spring AOP basics][12]). Open the *BusinessProfiler.java* file and copy the below code into it.

 [12]: http://static.springsource.org/spring/docs/2.5.4/reference/aop.html#aop-introduction-defn "Spring AOP basics"

```java

    package com.veerasundar.spring.aop;

    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;

    @Aspect
    public class BusinessProfiler {

            @Pointcut("execution(* com.veerasundar.spring.aop.*.*(..))")
            public void businessMethods() { }

            @Around("businessMethods()")
            public Object profile(ProceedingJoinPoint pjp) throws Throwable {
                    long start = System.currentTimeMillis();
                    System.out.println("Going to call the method.");
                    Object output = pjp.proceed();
                    System.out.println("Method execution completed.");
                    long elapsedTime = System.currentTimeMillis() - start;
                    System.out.println("Method execution time: " + elapsedTime + " milliseconds.");
                    return output;
            }

    }

```

Here's what this code does:

1.  Using *@AspectJ* annotation, we have declared that this class is an Aspect.
2.  Using *@Pointcut* annotation, we have defined a pointcut that will match the execution of all public method inside com.veerasundar.spring.aop package**.** [[read more about pointcut][13]]
3.  Using *@Around* annotation, we have defined a Around advice which will be invoked *before* and *after* our business method. i.e. @Around advice will wrap our business method. As you can see in the above code, *pjp.proceed()***.** This is when our business method gets called from @Around advice.

 [13]: http://static.springsource.org/spring/docs/2.5.4/reference/aop.html#aop-pointcuts "Spring Aspect Oriented Programming - Pointcut examples"

## 4. Configuring Spring AOP and @AspectJ support:

Open the *applicationContext.xml* file and copy the below code into it.

```xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

        
        <aop:aspectj-autoproxy />

        <bean id="businessProfiler" class="com.veerasundar.spring.aop.BusinessProfiler" />
        <bean id="myBusinessClass" class="com.veerasundar.spring.aop.BusinessImpl" />
    </beans>

```

Here's what we are doing in the above XML file:

1.  We have added the [required AOP schemas][14] on the top of the XML file.
2.  Using , we've enabled the @AspectJ support to our application.
3.  And then we defined two normal Spring beans - one for our Business class and the other for Business Profiler (i.e. our aspect).

 [14]: http://static.springsource.org/spring/docs/2.5.4/reference/xsd-config.html#xsd-config-body-schemas-aop "XML Schemas required for Spring AOP support"

That's it. With all the above code is done, we have successfully added Spring AOP support to our project and configured it. In the next step, lets test our code.

## 5. Testing the Spring AOP profiler:

Open the file *SpringAOPDemo.java* and copy the below lines into it.

```java

    package com.veerasundar.spring.aop;

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;

    public class SpringAOPDemo {

            /**
             * @param args
             */
            public static void main(String[] args) {
                    ApplicationContext context = new ClassPathXmlApplicationContext(
                                    "applicationContext.xml");
                    Business bc = (Business) context.getBean("myBusinessClass");
                    bc.doSomeOperation();
            }

    }

```

In the above code we are loading our Business bean from Spring Context and then calling our business method. If you run this class, it will produce the following output on the console.

```java

    Going to call the method.
    I do what I do best, i.e sleep.
    Done with sleeping.
    Method execution completed.
    Method execution time: 2000 milliseconds.

```
I hope this tutorial helps you to understand the basics of Spring Aspect Oriented programming. If you have any questions regarding the above example, feel free to leave a comment**.**

Spring AOP Example: Profiling method execution time tutorial


One of the common requirement in Java projects, that are [using Log4j logging][1], is to have different log files for each module (or layer) in the project. For example, if you have a web application, you may want to log the debug/info messages from the service layer to a _service.log_ file and the log messages from the presentation layer to the _web-app.log_ file and so on. This is very simple to achieve in Log4j.

[1]: https://veerasundar.com/blog/log4j-tutorial-adding-log4j-logging-to-your-project "How to add Log4j support to your project?  Follow these steps if you want to add Log4j logging support to your Java project."

Log4j has a concept called **Category** using which you can classify a package as a category and assign a appender to that category alone. To make this point clear, consider that we have the below Java classes in our project:

```java
    com.someapp.service.myservice.SomeServiceClass.java

    com.someapp.dao.SomeDaoClass.java
```


Now, if we want to send the log messages from SomeServiceClass.java to service.log and SomeDaoClass.java to dao.log files respectively, then the log4j configuration would be something like this:

```java
    log4j.category.com.someapp.service = INFO, serviceFileAppender
    log4j.category.com.someapp.dao = INFO, daoFileAppender
    log4j.rootLogger = INFO, defaultAppender
```

As you can see in above snippet, we are defining two categories for the *service* and *dao* packages and associating them with the appenders serviceFileAppender and daoFileAppender respectively. These two appender are just any file appenders configured somewhere in the same log4j.properties file. (Have a look at this article: [How to configure the File Appenders in Log4j][2]). So, all the log messages that coming from the classes which resides under the *com.someapp.service* package will go to the serviceFileAppender, which in turn will go to service.log. The same logic applies to dao.log also.

 [2]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-the-log-messages-to-a-file "how to create a FileAppender to log messages into a file, instead of console."

Apart from these two logs, we also defined the defaultAppender as the root logger. Means, the log messages from all the packages will go to defaultAppender, **including the service and dao log messages**. Yes! with the above configuration, the service and dao log messages will be there in two places. In their respective log appenders the defaultAppender.

But, there's a way to prevent this duplicate logging. Read my next post on **Additivity** to learn how.

Next: [Additivity: What and Why?][3]

 [3]: https://veerasundar.com/blog/log4j-tutorial-additivity-what-and-why "Article explains what is log4j additivity and how to use it."

Previous: [How to send the log messages to a File?][4]

 [4]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-the-log-messages-to-a-file "how to create a FileAppender to log messages into a file, instead of console.  Log4j FileAppender - exampe for Logging messages to a file"


Log4j Tutorial : How to send log messages to different log files?


If you are into Java enterprise application development, then get yourself ready to hear the terms '*Spring*', '*Dependency Injection*' or '*IoC*' a lot. Because, without these terms (and technologies) enterprise development wouldn't be this much simpler. Spring, the framework which became very popular because of it's capability to inject the dependencies to our Java objects in a very efficient manner. Spring's lightweight dependency injection container manages all the defined beans and their dependencies.

## So, what is this 'dependency injection' thing ?

**Dependency Injection** (or DI, in short) is nothing but the dependencies of your Java objects are managed by a **container** so that your object can concentrate on it's functionality rather than searching for it's dependencies. Here, it's the container's (for example Spring's container) responsibility to inject all the dependent objects that your class need. You just need to tell the container what you want and the container takes care of the rest.

Confusing, huh !?

## A Ground-breaking(!) HelloWorld2 App:

Let's take a simple example - a Web2.0 hello world - 'HelloWorld2'². You are writing a 'HelloWorld2'² class which has the capability to tweet the message you are giving. From this, it is clear that your 'HelloWorld2'² will need a TwitterService object to complete its task. So, usually you will declare a TwitterService variable in your 'HelloWorld2'² class, and you will instantiate a new 'TwitterService' object. The 'HelloWorld2'² may look like this:

```java
    class HelloWorld2
    {
    	TwitterService ts = new TwitterService();

    	public void sayHello(String name)
    	{
    		ts.tweet("Hello "   name);
    	}
    }
```

In the above, you are declaring and instantiating the TwitterService object in your HelloWorld2 code itself. In other words, _your code_ is responsible for getting it's dependent objects, in this case the TwitterService object.

Let's see a different version of HelloWorld2.

## The 'Dependency Injected' version of 'HelloWorld2'²:

Now, have a look at this code.

```java
    class HelloWorld2
    {
    	TwitterService ts = null;

    	public void setTs(TwitterService ts){
    		this.ts = ts;
    	}

    	public void sayHello(String name)
    	{
    		ts.tweet("Hello "   name);
    	}
    }
```

What's new in this version?! We've removed the TwitterService object creation, instead created a new setter method setTs() (I know, it's a bad name!). But, where is our mission-critical TwitterService object is getting created?

That's where the dependency Injection comes into play. The creation of objects will be _outsourced_ to the container. Let's outsource this task to the Spring container using a Spring configuration file.

In the above configuration file, we are defining the TwitterService as a _Spring managed_ bean and then, in the 'helloWorld' bean definition, we are telling the Spring container to _inject_ 'twitterService' bean for the property 'ts'. When the Spring container reads this XML file, it will create the 'helloWorld' bean and using the setter method for the variable 'ts', it will inject the 'twitterService' into 'helloWorld' . This technique is called as **_setter method injection_**(duh!).

Apart from this XML based configuration, Spring supports annotations based DI configuration also. I'll be explaining that in my next article.


Spring's Dependency Injection


By default, when you install XAMPP in your windows machine, the `root` password for the MySQL is set to empty. But this is not recommended, as the MySQL database without a password will be accessible to everyone. To avoid this, a proper/secure password must be set to the user `root`. To do it in XAMPP, there are two ways.

## Method 1: reset XAMPP MySQL root password through web interface:

After you started your XAMPP server, go to the browser and type the URL **http://localhost/security/** (incase you've [modified XAMPP server port][1], you need to include that port number also in previous URL). The security page will be shown where you can change the `root` password for MySQL. This will update the phpMyAdmin config also.

[1]: https://veerasundar.com/blog/how-to-change-xampp-server-port "How to change XAMPP server port?"

## Method 2: reset XAMPP MySQL root password through SQL update:

1.  Start the Apache Server and MySQL instances from the XAMPP control panel.
2.  After the server started, open any web browser and give **http://localhost:8090/phpmyadmin/** (if you are running XAMPP on 8090 port). This will open the phpMyAdmin interface. Using this interface we can manager the MySQL server from the web browser.
3.  In the phpMyAdmin window, select _SQL_ tab from the right panel. This will open the SQL tab where we can run the SQL queries.
4.  Now type the following query in the textarea and click **Go**  
    `UPDATE mysql.user SET Password=PASSWORD('password') WHERE User='root'; FLUSH PRIVILEGES;`
5.  Now you will see a message saying that the query has been executed successfully.
6.  If you refresh the page, you will be getting a error message. This is because the phpMyAdmin configuration file is not aware of our newly set root passoword. To do this we have to modify the phpMyAdmin config file.
7.  Open the file **[XAMPP Installation Path] / phpmyadmin / config.inc.php** in your favorite text editor.
8.  Search for the string `$cfg\['Servers'\]\[$i\]['password'] = '';` and change it to like this, `$cfg\['Servers'\]\[$i\]['password'] = 'password';` Here the 'password' is what we set to the `root` user using the SQL query.
9.  Now all set to go. Save the config.inc.php file and restart the XAMPP server.


This article explains how to change the MySQL root password in XAMPP for windows. When you install XAMPP, the default root password for MySQL would be empty, which is not recommended.

How to change the root password for MySQL in XAMPP?


This post is a tutorial on how to start your web site/blog. I am explaining it from the basics, so that it helps everyone.

This tutorial has two tracks - one is for the people who are willing to spend money for their web space and the other track is for the people who wants it FREE (Yes! for Free. ![:D][1] ) So, here it goes.

[1]: https://veerasundar.com/blog/wp-includes/images/smilies/icon_biggrin.gif

### I can spend money for my web identity!

1.  As you are ready to spend some bucks, you have hundreds of options out there. First thing you need to decide is what you are going to start - is it a **blog or web site**. Nowadays most of the people have both blog and web sites in a single domain. So, its good to go with both.
2.  Now **choose a domain name** for your web site. Its very important that choosing a good name for your domain. If you are planning for a personal web site, you could name it as your name (eg, veerasundar.com). If you are planning to make money from your web site, then the domain should match your web content! This step is very important in getting traffic (I mean the people!) for your web site. Once you decided on the domain name, you could use web service like to check the availability of the name. This service also tells you who owns a domain name if it has already taken.
3.  Now **buy the domain. **There are numerous providers out there, selling domain names. For example, [Godaddy][2] is a very famous one. A .com domain usually costs about 250 RS and a .in domain costs around 500 RS. (.in was one of the dead [cheap domains][3] three months back, but now its costlier than .com domain. Economy kills the web business also! ![:(][4] ) I am using [eWebGuru][5] for my domain names. ( I own three domains! ![:D][1] )
4.  Next step is to **buy the web hosting service**. Again, numerous providers and multiple plans out there. Choosing a hosting plan is depends on what you want to put on your web site. All the hosting companies must have their plans listed on their web site. Go through it and choose accordingly. Below are the specifications for my web site. (its from [eWebGuru][5])
    - Web space : 20 MB
    - Monthly Transfer bandwidth : 1 GB
    - Number of Database allowed : 2
    - Price : 1000 RS/Year
5.  While buying the web hosting, you can either buy a Domain name at that time or you can use your own domain name, if you have already bought one. In my experience its **good to buy both the domain name and web space from the same provider**, so that you will get good support for any problem.
6.  Once you bought the hosting service, you will be receiving the web site address (ie. the domain name) and IP address, FTP user name and password. Most of the providers using [CPanel][6] for managing the web sites. You will be given access to CPanel through which you can manage your web space. (Adding databases, creating sub domains, viewing logs are done through CPanel)
7.  Now you got web site name and space for your web site. Its time to put some thing on your web site. You can check out this site [Open Source Web Design][7] to get templates for your web site. Or just google for the word Web templates and you will be flooded with results. ![:D][1]
8.  Now you need to FTP the design to your web space. There are commercial FTP clients are available, but I use [WinSCP][8] which is free, open source and reliable. Use the FTP address given by your provider to connect to your web space and transfer your design/data.
9.  That's it about creating your own web site/blog.

[2]: http://www.godaddy.com
[3]: http://www.hostingobserver.com/cheapest-domain-host.php
[4]: https://veerasundar.com/blog/wp-includes/images/smilies/icon_sad.gif
[5]: http://client.ewebguru.com/aff.php?aff=1352
[6]: http://www.cpanel.net
[7]: http://oswd.org
[8]: http://winscp.net

### I want it free! (I am a poor guy, you know! ![:-(][4] )

1.  As you are not willing to spend money for your web identity, below steps will explain you how to use free hosting services for your blog. This post mainly focused on Blogs rather than web sites.
2.  The popular Free blogging services are **[Blogger][9], [WordPress][10] and [Livejournal][11].** You need to open a account in the blogging service you want.
3.  Once you opened your account, then creating a blog is a child's play. Just follow the instructions, then you are done.
4.  One point here is, your domain name will include the blogging service provider name. For example, my blogger blog is [www.veerasundar.blogspot.com][12] and my wordpress blog is [www.veerasusndar.wordpress.com][13]. This is not the case if you buy the domain. ![:D][1]
5.  In my personal opinion, Blogger is a very good service for starters. It allows lots of customization to be added in your blog. And it is from the Google GOD, so it rocks! ![:P][14]
6.  Consider [WordPress.org][15] for running your blog on your own web space.

[9]: http://blogger.com
[10]: http://wordpress.com
[11]: http://livejournal.com
[12]: http://www.veerasundar.blogspot.com
[13]: http://www.veerasusndar.wordpress.com
[14]: https://veerasundar.com/blog/wp-includes/images/smilies/icon_razz.gif
[15]: http://wordpress.org


#tutorial (15)