Let me work on the JQuery this week

When I heard about it first time, it sounded like to be a framework involving J, well I was thinking, what all could start with J; could it be Java, Jython, Javascript; well for now I strongly think it is Javascript, probably helping query the DOM and above it.

I will soon do a quick study on it...

Differences Webserver, Servlet Container, Application Server

These are the major differences among the following:

Features	Web-Server	Servlet Container	Application Server
HTTP Server – serves static content including Html pages, images using HTTP Protocol	Y	May include Web-Server/interfaced it with Web-Server/Pluggable. Webserver redirects the HTTP requests to Servlet container	Combination of Web-Server and Servlet Container?
Supports CGI scripts like Perl	Y	N	N
Serves dynamic content using JSPs/Servlets	N	Y	Y
Thread/Connection Pooling/Multi-threading	N	Y	Y
Transaction handling	N	N	Y
Load balancing	Y		Y
Clustering	N	N	Y
Jndi	N	Y	Y
EJB Container	N	N	Y
J2EE Compliance	N	Partially supported	Y
.war installation	N	Y	Y
.ear installation	N	N	Y
Security	N	N	Y
Scalability	N	N	Y
Reliability	N	N	Y
Messaging	N	N	Y
Examples	Apache HTTP Server	Tomcat (contains Apache internally)	IBM Websphere, Oracle Weblogic, JBoss

What's up with Maven?

Draft of Notes:

Yes, you must be thinking about what is up with Maven, if you just heard about it, but did not have a date with it.

Highlights:

Maven features the build, dependency management (including reflexive) tool mainly for Java programming language, resolves dependencies, supports multi-module projects.

You must have heard about Ant: it is a build only tool, written in script. Both are XML based.

So I can say Maven is a super-set of what Ant provides.

Installation: Refer to apache site

Let us check on the concepts, terms in Maven:

It covers build, test, deploy of any given Java project; the outcome would be .jar, .war or .ear file.

In Ant, it has build.xml script, Maven has got pom.xml file. Yes, in long, it is call Project Object Model, based on Xml schema.

It has got default life cycle (named 'install'); containing ordered execution of plugins; each plugin has goals, default is declared.
Defaults are good are called as Convention. If it has to be customized; it is called Configuration. In short, it is also called as Convention over Configuration.

Default life cycle ->Phases: each phase is represented by Plugin and a default goal:

Phases in order: these phases can be individually be invoked using commands

Validate
Compile -> mvn compile
Test -> mvn test
Package -> mvn package
Integration-test
Verify
Install
Deploy

Notice, when mvn install is run, all the phases upto install will be run in sequence.

mvn clean: life cycle phases -> pre-clean, clean, post-clean

To run mvn command, you must specify a valid lifecycle phase or a goal in the format
plugin-prefix:goal or plugin-group-id:plugin-artifact-id:[]:goal

Available lifecycle phases are:
validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean, pre-site, site, post-site, site-deploy.

Sample commands; invokes default life cycle
mvn clean
mvn install
mvn clean install
mvn site

Android programming

Setting aside some time and do hands on with Android Programming.

Android is an OS designed for mobile devices. It could be used by developers of mobile applications to be used as a framework.

Here are the developer notes:

Tools:
Install the following
Jdk 1.6
Eclipse IDE helios 3.6: default choice for edit, debug, profile.
ADT 8.0.1 (Android development tools): Eclipse plugin. Run-time environment.
AVD: Android Virtual Device: Consists of Emulators, in short they are virtual devices providing environment to develop/test applications.
SDK: API library and tools

Basic building blocks of any Android application:
-Starting activity class(es): The actual Java coding goes here; including event handling and so on.
-Layout resource file
-AndroidManifest.xml (listing of activity classes goes in here)
-strings.xml (contains hard strings, that could be referred in other parts of the application)
-R.java
-Android library

Creating a simple Android application in Eclipse provides all basic building blocks. You can even launch it in Eclipse.

Design Patterns: What are they about?

They are about known solutions to common problems which occur/already occurred and has been documented. I have heard a lot about GoF patterns; in short four individuals have coined a set of patterns. These patterns are related with common application programming design issues, so we can follow them instead of re-inventing them; thus saving us time on the project. They are programming language independent, but mostly oriented towards object based languages like Java, .Net.

Patterns are categorized into 4 sets:

Creational -> Structural -> Behavioral -> Concurrency Patterns.

You might think why did I drew arrows. It is simple, as you might have guessed. Various patterns co-exist, so they have to behave well, for them to behave; need to have structure, and first they need to be created.

Creational: deals with how object is to be created

. . . will be continued

Whats up with Testing frameworks?

Since past few weeks I have been working on finding about open source testing frameworks available that can be used to test various kinds of applications/components. For example unit testing DAOs, mock objects, Jsf black box testing.

Let me list out some of them here:

JUnit:

JsfUnit: Black-box testing from the point that it snoops Jsf tree components, FacesContext, Converters, Validators, Managed beans, Messages.

HtmlUnit:

Cactus:

Arquillian:

TestNG: The test cases look more like that of JUnit, though both use Annotations, but TestNG based annotations are powerful, such as those which roll-back database transactions post test run. It is useful to test DAOs; not limited to them.

EasyMock: It is useful in cases where you don't want your tests to access database (not even read it) and provide the input data and the expected data (instead of database) to the test cases directly; so there is no question of rolling back database transactions post tests run. It is useful for Service layer classes since they access DAOs.

Selenium:

Shale:

Whats up with Amazon Cloud and Cloud Computing?

Let me fly you into the clouds and see for yourself what they take to build one . . . are we already using them in our T-lives (in)directly, who will use it, how can you use them under what scenario . . . is it all new Or leveraging already existing technologies by integrating them for our benefit?