JAAVAA

Microsoft Outlook shortcuts

2013-09-22T23:29:00.001-07:00

Below are the shortcuts I learnt and like and might forget over time!
Hence keeping it here for future reference.

Purpose	How to do it?
Follow up/Add reminder an email in reading pane	Insert button or ctrl+shift+g
Follow up/Add reminder an email when the mail is opened	ctrl+shift+g
Go to diff folder	Ctrl + y

Fluent API

2013-09-18T07:46:00.000-07:00

Did some reading of articles on Fluent and related DSL . Found some good posts like below:
http://blog.jooq.org/2012/01/05/the-java-fluent-api-designer-crash-course/

But the real good one is from the guru, called founder of Fluent Martin Folwer's post:
http://martinfowler.com/bliki/FluentInterface.html

Multi-threading through ExecutorService or ExecutorCompletionService from java.util.concurrent package

2013-08-22T03:30:00.000-07:00

java.util.concurrent package has lot of utility Classes/Interfaces which can be used to create good multi-threading programs. Lot of boiler plate code like creation of Threads and maintenance of the same has be taken take by these classes.

Below code explains the 2 different ways of achieving the same. All the classes are from java.util.concurrent package.

The scope of an individual task here is to wait for 2 seconds and come out.

And 10 such tasks should be executed.

singleThreadWay()is a version of single threaded model which takes ~20 seconds [10 * 2]

multiThreadedWayWithExecutorService() is a version of multi-threaded model using ExecutorService which takes ~2 seconds!

ExecutorService has different methods to support Runnable (which doesn’t return any response) and Callable (which return response).

· execute(Runnable)

· submit(Runnable)

· submit(Callable)

· invokeAny(...)

· invokeAll(...)

One can create ExecutorService depends on the implementation you use. However, you can use the Executors factory class to create ExecutorService instances too. Here are a few examples of creating an ExecutorService:

ExecutorService executorService1 = Executors.newSingleThreadExecutor();

ExecutorService executorService2 = Executors.newFixedThreadPool(10);

ExecutorService executorService3 = Executors.newScheduledThreadPool(10);

The ExecutorService’s submit method used in the code puts the task and exits. It doesn’t wait for the response to come. It just returns the handle to the response in the form of Future.

The actual response can be retried from issuing get method of Future.

multiThreadedWayWithExecutorCompletionService() is a version of multi-threaded model using ExecutorCompletionService which takes ~2 seconds!

This CompletionService is a wrapper around ExecutorService.

It also gives the handle on Future for response. But there is a better way to get the response i.e. the CompletionService has a method take() which returns Future again but flushes the internal queue. Hence a better approach to read the response.

The other important aspect of CompletionService is the responses are accumulated as when they are available. More explanation is found in next section.

public class MultiThreadingExample {

public static void main(String[] args) throws InterruptedException, ExecutionException {

long startTime = System.currentTimeMillis();

singleThreadWay();

multiThreadedWayWithExecutorService();

multiThreadedWayWithExecutorCompletionService();

long endTime = System.currentTimeMillis();

System.out.println("Total time taken by process is " + (endTime - startTime));

}

private static void singleThreadWay() throws InterruptedException {

for (int i = 0; i < 10; i++) {

Thread.sleep(2000l);

System.out.println("Asynchronous task");

}

private static void multiThreadedWayWithExecutorService() throws InterruptedException, ExecutionException {

ExecutorService executorService = Executors.newFixedThreadPool(10);

List<Future<?>> futures = new ArrayList<Future<?>>();

for (int i=0; i<10; i++) {

futures.add

(executorService.submit(new Callable<Object>() {

public Object call() throws Exception {

System.out.println("Asynchronous task");

Thread.sleep(2000l);

return "I'm done";

}

}));

}

for(Future<?> f:futures) {

System.out.println(f.get());

}

executorService.shutdown();

}

private static void multiThreadedWayWithExecutorCompletionService() throws InterruptedException, ExecutionException {

ExecutorService executorService = Executors.newFixedThreadPool(10);

CompletionService<Object> completionService = new ExecutorCompletionService<Object>(executorService);

for (int i=0; i<10; i++) {

completionService.submit(new Callable<Object>() {

public Object call() throws Exception {

System.out.println("Asynchronous task");

Thread.sleep(2000l);

return "I'm done";

}

});

}

for (int i=0; i<10; i++) {

System.out.println(completionService.take().get());

}

executorService.shutdown();

}

If the ExecutorService is Spring injected, below is the syntax:

<bean id="myExecutor" class="java.util.concurrent.Executors"

factory-method="newFixedThreadPool" destroy-method="shutdownNow">

<constructor-arg value="10"/>

</bean>

ExecutorService vs ExecutorCompletionService:

Suppose you had a set of tasks A, B, C, D, E and you want to execute each of them asynchronously in an Executor and process the results 1 by 1 as they complete.

With an Executor, you would do so like this:

List<Future<?>> futures = new ArrayList<Future<?>>();

futures.add(executorService.submit(A));

futures.add(executorService.submit(B));

futures.add(executorService.submit(C));

futures.add(executorService.submit(D));

futures.add(executorService.submit(E));

//This loop must process the tasks in the order they were submitted: A, B, C, D, E

for (Future<?> future:futures) {

? result = future.get();

// Some processing here

}

The problem with this method is that there is no guarantee that task A will complete first. Thus, it is possible that the main thread will be blocking idly waiting for task A to complete when it could be processing the result of another task (say task B). Result processing latency could be reduced by using an ExecutorCompletionService.

List<Future<?>> futures = new ArrayList<Future<?>>();

futures.add(executorCompletionService.submit(A));

futures.add(executorCompletionService.submit(B));

futures.add(executorCompletionService.submit(C));

futures.add(executorCompletionService.submit(D));

futures.add(executorCompletionService.submit(E));

//This for loop will process the tasks in the order they are completed, regardless of submission order

for (int i=0; i<futures.size(); i++) {

    ? result = executorCompletionService.take().get();

    // Some processing here

So, in essence, ExecutorCompletionService could be used to squeeze out a little more efficiency when the order of processing task results does not matter.

One important thing to note though. The implementation of ExecutorCompletionService contains a queue of results. If take or poll are not called to drain that queue, a memory leak will occur. Some people use the Future returned by submit to process results and this is NOT correct usage.

The other explanation of the difference from javadoc:

I think the javadoc best answers the question of when the CompletionService is useful in a way an ExecutorService isn't.

A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.

Basically, this interface allows a program to have producers which create and submit tasks (and even examine the results of those submissions) without knowing about any other consumers of the results of those tasks. Meanwhile, consumers which are aware of the CompletionService could poll for or take results without being aware of the producers submitting the tasks.

Another good example found in javadoc below:

A CompletionService that uses a supplied Executor to execute tasks. This class arranges that submitted tasks are, upon completion, placed on a queue accessible using take. The class is lightweight enough to be suitable for transient use when processing groups of tasks.

Usage Examples. Suppose you have a set of solvers for a certain problem, each returning a value of some type Result, and would like to run them concurrently, processing the results of each of them that return a non-null value, in some method use(Result r). You could write this as:

void solve(Executor e, Collection<Callable<Result>> solvers)

throws InterruptedException, ExecutionException {

CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);

for (Callable<Result> s : solvers)

ecs.submit(s);

int n = solvers.size();

for (int i = 0; i < n; ++i) {

Result r = ecs.take().get();

if (r != null)

use(r);

}

Suppose instead that you would like to use the first non-null result of the set of tasks, ignoring any that encounter exceptions, and cancelling all other tasks when the first one is ready:

void solve(Executor e, Collection<Callable<Result>> solvers)

throws InterruptedException {

CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);

int n = solvers.size();

List<Future<Result>> futures = new ArrayList<Future<Result>>(n);

Result result = null;

try {

for (Callable<Result> s : solvers)

futures.add(ecs.submit(s));

for (int i = 0; i < n; ++i) {

try {

Result r = ecs.take().get();

if (r != null) {

result = r;

break;

}

} catch(ExecutionException ignore) {}

}

finally {

for (Future<Result> f : futures)

f.cancel(true);

}

if (result != null)

use(result);

}

shutdown()/shoutdownNow()

When you are done using the ExecutorService you should shut it down, so the threads do not keep running.

For instance, if your application is started via a main() method and your main thread exits your application, the application will keep running if you have an active ExexutorService in your application. The active threads inside this ExecutorService prevents the JVM from shutting down.

To terminate the threads inside the ExecutorService you call its shutdown() method. The ExecutorService will not shut down immediately, but it will no longer accept new tasks, and once all threads have finished current tasks, the ExecutorService shuts down. All tasks submitted to the ExecutorService before shutdown() is called, are executed.

If you want to shut down the ExecutorService immediately, you can call the shutdownNow() method. This will attempt to stop all executing tasks right away, and skips all submitted but non-processed tasks. There are no guarantees given about the executing tasks. Perhaps they stop, perhaps the execute until the end. It is a best effort attempt.

References:

How to import existing project again in Eclipse?

2013-08-21T03:23:00.003-07:00

How to import existing project again in Eclipse?

Assume there is a maven project ABCD in Eclipse workspace.

Now you have a requirement to import the same project of different version.

Since the project name is same for the existing and one you are trying to import now, Eclipse doesn’t allow you to do that and says – ‘Project ABCD is already imported into workspace.’

To solve this, one can use advanced options of maven project import like below:

Expand Advanced option
Check Resolve Workspace projects
In Name Template, there are already predefined options which you can use
Example: [artifactId] or [artifactId]-[version] etc. I prefer to override this a bit and do like this - [artifactId]-9.5.4 if the version of the project is 9.5.4. The reason is, if the version is snapshot version, then it’ll create the project something like ABCD-9.5.4-SNAPSHOT which I don’t like!

Concurrency safe HashMap

2013-08-20T00:21:00.002-07:00

The solution is java.util.concurrent.ConcurrentHashMap<K,V>

A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates. This class obeys the same functional specification as Hashtable, and includes versions of methods corresponding to each method of Hashtable. However, even though all operations are thread-safe, retrieval operations do not entail locking, and there is not any support for locking the entire table in a way that prevents all access. This class is fully interoperable with Hashtable in programs that rely on its thread safety but not on its synchronization details.

Retrieval operations (including get) generally do not block, so may overlap with update operations (including put and remove). Retrievals reflect the results of the most recently completed update operations holding upon their onset. For aggregate operations such as putAll and clear, concurrent retrievals may reflect insertion or removal of only some entries. Similarly, Iterators and Enumerations return elements reflecting the state of the hash table at some point at or since the creation of the iterator/enumeration. They do not throw ConcurrentModificationException. However, iterators are designed to be used by only one thread at a time.

The allowed concurrency among update operations is guided by the optional concurrencyLevel constructor argument (default 16), which is used as a hint for internal sizing. The table is internally partitioned to try to permit the indicated number of concurrent updates without contention. Because placement in hash tables is essentially random, the actual concurrency will vary. Ideally, you should choose a value to accommodate as many threads as will ever concurrently modify the table. Using a significantly higher value than you need can waste space and time, and a significantly lower value can lead to thread contention. But overestimates and underestimates within an order of magnitude do not usually have much noticeable impact. A value of one is appropriate when it is known that only one thread will modify and all others will only read. Also, resizing this or any other kind of hash table is a relatively slow operation, so, when possible, it is a good idea to provide estimates of expected table sizes in constructors.
This class and its views and iterators implement all of the optional methods of the Map and Iterator interfaces.

Like Hashtable but unlike HashMap, this class does not allow null to be used as a key or value.
This class is a member of the Java Collections Framework.

SQL Truncate vs Delete command

2013-07-31T00:20:00.001-07:00

There are two main keywords used for deleting data from a table: TRUNCATE and DELETE. Although each achieves the same result, the methods employed for each vastly differ. There are advantages, limitations, and consequences of each that you should consider when deciding which method to use.

Deleting Data Using TRUNCATE TABLE

TRUNCATE TABLE is a statement that quickly deletes all records in a table by deallocating the data pages used by the table. This reduces the resource overhead of logging the deletions, as well as the number of locks acquired; however, it bypasses the transaction log, and the only record of the truncation in the transaction logs is the page deallocation. Records removed by the TRUNCATE TABLE statement cannot be restored. You cannot specify a WHERE clause in a TRUNCATE TABLE statement-it is all or nothing. The advantage to using TRUNCATE TABLE is that in addition to removing all rows from the table it resets the IDENTITY back to the SEED, and the deallocated pages are returned to the system for use in other areas.

In addition, TRUNCATE TABLE statements cannot be used for tables involved in replication or log shipping, since both depend on the transaction log to keep remote databases consistent.
TRUNCATE TABLE cannot used be used when a foreign key references the table to be truncated, since TRUNCATE statements do not fire triggers. This could result in inconsistent data because ON DELETE/UPDATE triggers would not fire. If all table rows need to be deleted and there is a foreign key referencing the table, you must drop the index and recreate it.

Deleting Data Using DELETE FROM Statement

DELETE TABLE statements delete rows one at a time, logging each row in the transaction log, as well as maintaining log sequence number (LSN) information. Although this consumes more database resources and locks, these transactions can be rolled back if necessary. You can also specify a WHERE clause to narrow down the rows to be deleted. When you delete a large number of rows using a DELETE FROM statement, the table may hang on to the empty pages requiring manual release using DBCC SHRINKDATABASE (db_name).

When large tables require that all records be deleted and TRUNCATE TABLE cannot be used, the following statements can be used to achieve the same result as TRUNCATE TABLE:

DELETE from "table_name"
DBCC CHECKIDENT("table_name", RESEED, "reseed_value")

How to embed Jetty servlet container in a application

2013-07-30T07:48:00.001-07:00

Recently came across a requirement where in we needed a web app which contains one servlet alone.

Since it is really really small sized requirement, we didn’t wanted to invest in big web app containers.

I got to know about this servlet container called as Jetty which can be used for this purpose.

The beauty of this is you don’t need to install any web application as such (you still can if you choose to!).

All you have to do is create a project which has a servlet and Jetty jars. Once you install the process and start, it can open http port and start listening on that port for you! This is called as embedding Jetty.

I could see lot of advantages of Jetty and why one should use at below site:

https://www.webtide.com/choose/jetty.jsp

The detailed reference documentation can be found at:

http://www.eclipse.org/jetty/documentation/current/index.html

One sample servlet I found on net which opens up a http port and starts responding to the requests on the port:

package org.eclipse.jetty.embedded;

import java.io.IOException;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.server.Server;

import org.eclipse.jetty.servlet.ServletHandler;

public class MinimalServlets {

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

Server server = new Server(8080);

ServletHandler handler = new ServletHandler();

server.setHandler(handler);

handler.addServletWithMapping(HelloServlet.class, "/*");

server.start();

server.join();

}

public static class HelloServlet extends HttpServlet {

@Override

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

response.setContentType("text/html");

response.setStatus(HttpServletResponse.SC_OK);

response.getWriter().println("<h1>Hello SimpleServlet</h1>");

}

Creation of ArrayList from String array

2013-06-27T02:37:00.003-07:00

import java.util.Arrays;

import java.util.List;

public class Junk {

public static void main(String[] args) {

List<String> stringCollection = Arrays.asList(

new String[] {"a" , "b", "c", "d", "e"});

}

Sub-collection or batch creation from a big collection

2013-06-27T02:32:00.002-07:00

Requirement is I have a list like [a, b, c, d, e] and I want to create batch/sublist of size 2 (last sublist can be of size 1 or 2).
I.e. the output should be [[a, b], [c, d], [e]].

One options is to use java.util.List.sublist() method which returns the subcollection for given index which you need to maintain.
Google's Guava APIs have lot of such utility methods using which you can achieve the needed thing in one line.

Example:

import java.util.Arrays;

import java.util.List;

import com.google.common.collect.Lists;

public class Junk {

public static void main(String[] args) {

List<String> stringCollection = Arrays.asList(

new String[] {"a" , "b", "c", "d", "e"});

int batchSize = 2;

List<List<String>> subBatches = Lists.partition(stringCollection, batchSize);

for (List<String> subBatch : subBatches) {

// Do what you want with each sub batch!

}

}

Lot of such utility methods are available @
http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Lists.html
http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect

Definiing method level Generics

2013-06-27T01:06:00.000-07:00

How to define Generics at method level:

public class MethodLevelGenericTest {

public static void main(String[] args) {

Actor actor = new Actor();

actor.setName("Arnold");

Dancer dancer = new Dancer();

dancer.setName("MJ");

Singer singer = new Singer();

singer.setName("JLo");

System.out.println(actor.getName());

System.out.println(dancer.getName());

System.out.println(singer.getName());

}

// Magical method with Generics!

public static <person extends Person> String getName(person p) {

return p.getName();

}

This prints:

Arnold

JLo

public class Actor extends Person {

private String profession;

public String getProfession() {

return profession;

}

public void setProfession(String profession) {

this.profession = profession;

}

public class Dancer extends Person {

private String profession;

public String getProfession() {

return profession;

}

public void setProfession(String profession) {

this.profession = profession;

}

public class Singer extends Person {

private String profession;

public String getProfession() {

return profession;

}

public void setProfession(String profession) {

this.profession = profession;

}

}

The other scenario of Bounded Wildcards is explained well in below article:
http://code.scottshipp.com/2013/07/23/collections-of-objects-of-different-types-and-the-bounded-wildcard/

SQL sort in custom order

2013-06-26T06:32:00.001-07:00

I came across a requirement where in I had to fetch records from DB in some specific order.
Example, Get all the records from credit_card table with all master_cards first, visa 2nd, amex 3rd etc.
The regular sort by clause doesn't work.

The solution is here:

SELECT * FROM TABLE_CREDIT_CARD

ORDER BY CASE

WHEN CARD_TYPE='MASTER_CARD' THEN 1

WHEN CARD_TYPE='VISA' THEN 2

WHEN CARD_TYPE='MAESTRO' THEN 3

WHEN CARD_TYPE='AMEX' THEN 4

ELSE 5

END

Protobuff example/articles

2013-04-18T03:27:00.001-07:00

Google's site has some good documentation on various aspects of protobuf:
Developer Guide: https://developers.google.com/protocol-buffers/docs/overview
Language guide: https://developers.google.com/protocol-buffers/docs/proto
Javadoc: https://developers.google.com/protocol-buffers/docs/reference/java/index
Generated class file: https://developers.google.com/protocol-buffers/docs/reference/java-generated

Below is the best tutorial/sample program I could find and it is from Google's site:
https://developers.google.com/protocol-buffers/docs/javatutorial

Collection Utility methods

2012-12-27T01:17:00.002-08:00

There are many times I need to do operations on Collections like empty check, comparison etc.
I use apache commons CollectionUtils.

http://commons.apache.org/collections/apidocs/org/apache/commons/collections/CollectionUtils.html

Eclipse shortcuts

2012-10-04T21:41:00.003-07:00

From Ranch

2012-10-01T00:32:00.003-07:00

FAQs from RANCH:
https://www.coderanch.com/how-to/java/Java-FAQ

Display Hibernate Sql Parameter Values

2012-07-13T00:19:00.004-07:00

I came across this post from mkyong.com on how to print sql parameters passed to DB when using Hibernate as ORM.

The solution uses P6Spy.

More details: http://www.mkyong.com/hibernate/how-to-display-hibernate-sql-parameter-values-solution/

Object to Pretty print XML

2012-06-27T00:57:00.002-07:00

You need xstream-x.x.x.jar to perform this.

import com.thoughtworks.xstream.XStream;

public class Junk {

private static XStream xstream = new XStream();

public static void main(String[] args) {

Address address = new Address("Summer street", "10th cross", "Ma", "560450");

Person person = new Person("Robert", "Plumber", address);

System.out.println(xstream.toXML(person));

}

class Person {

String name;

String job;

Address address;

public Person(String name, String job, Address a) {

this.name = name;

this.job = job;

address = a;

}

class Address {

String street;

String cross;

String area;

String pinCode;

public Address(String s, String c, String a, String p) {

street = s;

cross = c;

area = a;

pinCode = p;

}

And the output looks like below:

<name>Robert</name>

<job>Plumber</job>

<street>Summer street</street>

<cross>10th cross</cross>

</address>

</Person>

Tools I like

2012-06-25T05:26:00.001-07:00

Console

Console is a Windows console window enhancement. Console features include: multiple tabs, text editor-like text selection.

Better tool to use instead of windows command prompt.

Download site: http://sourceforge.net/projects/console/

Putty Connection Manager

One of the major features is the ability to display multiple PuTTY sessions in Tabs.

More details available at http://www.thegeekstuff.com/2009/03/putty-extreme-makeover-using-putty-connection-manager/

Download site: http://www.thegeekstuff.com/scripts/puttycm.zip

Launchy

Launchy indexes the programs in your start menu and can launch your documents, project files, folders, and bookmarks with just a few keystrokes!

Download site: http://www.launchy.net/download.php

Greenshot

Greenshot is a light-weight screenshot software tool with features like complete or partial screenshots, annotate, highlight or obfuscate parts of the screenshot or Send the screenshot to a file, the clipboard, a printer or as e-mail attachment.

Download site: http://getgreenshot.org/downloads/

Sublime Test

A notepad/text pad with cool features.

Download site: http://www.sublimetext.com/2

How to upload jar to local Maven repository?

2012-02-12T23:33:00.000-08:00

It can be achieved using mvn deploy:deploy-file command like below:

mvn deploy:deploy-file -DgroupId=com.ragsetty.testProj -DartifactId=testProj -Dversion=1.2.3 -Dfile=C:/ragsetty/projects/testProj-12.jar -DrepositoryId=com.ragsetty.testProj -Durl=file:///C:/path-to-my-local-repository -Dpackaging=jar

Unix ps equivalent on windows (dos command)

2012-01-11T07:48:00.000-08:00

There is a dos command which can be used to see the list of JVMs running on machine.
It is jps - Java Virtual Machine Process Status Tool.

The jps tool lists the instrumented HotSpot Java Virtual Machines (JVMs) on the target system. The tool is limited to reporting information on JVMs for which it has the access permissions.

Usage:

jps
jps -m
jps -l
jps -v
jps -V
jps -mlvV

When to use mvn:install vs mvn:deploy

2012-01-09T04:46:00.000-08:00

mvn:deploy is used in the projects whose need is to upload the artifact or outcome of the build to centralized repository so that the dependant projects can also consume. These are typically the projects which can’t run on their own but referred by other projects. May be as a jar. This also adds the artifact on local repository.

mvn:install is used in those projects which needs the artifact on the local repository only and not in the centralized repository. Typically the project outcome is consumed only locally not used by other projects. These are the projects which can run on their own.

How to find open connections with Oracle database

2012-01-09T04:24:00.000-08:00

If you want to know the open or active or inactive connections with Oracle DB,
1. Login to that Oracle schema (may be through Toad or Oracle etc) and
2. Run below sql
select sid,serial#,PROGRAM,machine,TO_CHAR(logon_Time,'DD-MON-YYYY HH24:MI:SS') AS logon,status from v$session where username='userNameWhichIWouldHaveUsedToConnect';

Maven commands - cheat-sheet

2011-12-06T23:33:00.000-08:00

Option	Command	Description
Skip Junits	mvn clean install -DskipTests=true	Skips all the JUnits
Force Update	mvn -U clean install	Default behaviour of mvn clean install is to check the dependencies once a day. If your teammates are changing the artifacts and you want to pick the latest from your local repository when you build, then go for this option.
Building from specified local repository	mvn clean install -Dmaven.repo.local= /location_to_temp_repo	Before committing your changes, you want to be sure that you didn’t introduce any unavailable dependency. However, such dependencies may be in your local repository, and so you want to be sure they can still be retrieved and used. Deleting your local maven repository completely may do the job, but … it’s not necessarily what you want. The maven.repo.local variable allows configuring the local repository location of Maven. This creates a complete new local repository at the specified location. In other words, you will compile your projects from scratch checking that you’re not using non-available artifacts from your (main) local repository. For sure it takes more time, but that’s the price to pay. On windows I first tried mvn clean install –Dmaven.repo.local=c:\dev\temp-repo. It bombed saying C-plugin in not available etc. Then I tried with –Dmaven.repo.local=./temp-repo which downloaded the artifacts under c:\temp-repo (it creates) folder and built the same successfully. So, the path name should be reference to root.

Sources for this post:

Mastering The Maven Command Line – Managing Dependencies

Checking free disk space on unix file system

2011-12-06T21:46:00.000-08:00

The df command is used to show the amount of disk space that is free on file systems.

Mount level space information:

df or df -k
This default action is to display used and free file space in blocks. In this particular case, the block size is 1024 bytes as is indicated in the output.

The first column show the name of the disk partition. Subsequent columns show total space, blocks allocated and blocks available. The capacity column indicates the amount used as a percentage of total file system capacity.

The final column show the mount point of the file system. This is the directory where the file system is mounted within the file system tree. Note that the root partition will always show a mount point of /. Other file systems can be mounted in any directory of a previously mounted file system.

If you want to check the space details for a mount, cd to that location and issue the command df . or df -k .

df -i: This option instructs df to display information about inodes rather that file blocks.

File level space information:

du command tells you how much space each folder in the current folder occupies
This command comes with many options. Try `du --help' for more information.

How to create a simple java project using Maven archetype - maven-archetype-quickstart

2011-09-15T02:05:00.000-07:00

In command prompt, type below command:

mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.mycompany.app -DartifactId=my-app

This starts running in interactive mode.

It first asks archetype number. Type 16 (which corresponds to maven-archetype-quickstart) and Enter
Then it asks version. By default it shows 1.0-SNAPSHOT. If you want some other version, enter what version you want
Similarly it asks for package.

Now, it would have created the folder 'my-app' and the project structure.