I’m now accepting students into my Java Programming Fundamentals for Absolute Beginners!

https://www.udemy.com/core-java-fundamentals/?couponCode=SALE75

Java Programming Fundamentals for Absolute Beginners

Life Cycles

In this post, I would be publishing the life cycles of various Java artifacts such as: Java Object, Threads, Applets, Servlets, Listeners, Filters, JSPs, EJBs, JMS (MDBs), Hibernate, JSF, Struts, WebServices, Spring Bean, Camel Routes.
Also the OSGi based artifacts such as Bundles, Services, Features and so on. I think this would help developers to refresh and refer them when they need them the most.
Struts 2 Life Cycle
OSGi Bundle Life Cycle
Thread Life Cycle
JSF Life Cycle
Servlet Life Cycle, Other one 
Spring Bean Life Cycle
Hibernate Object Life Cycle
iBatis 
JSP Life Cycle

SOA

SOA the Service Oriented Architecture, is all over my mind. To me as a developer cum designer it means a lot. It is changing the paradigm of how we used to program vs how it is empowering us to design applications in a newer way; so there is shift in terms of writing lots of code to writing lesser code and more configuration.

About Service-oriented_architecture

Differences between SOA and ESB

Here is the new Jargon/terminology I am learning them, keeping abreast of the technology:

OSGi: Features is a collection of Bundles (.jar) but allows export and import of packages

OSGi framework implementations: Felix, Equinox, Knopflerfish, Concierge

Maven: Great support to build OSGi based artifacts

Enterprise Integration Patterns (EIP): 65 to date? Popular ones are listed here:? Read popular book by Gregor Hohpe and Bobby Woolf

Enterprise Service Bus (ESB): Supports communication mechanism between various protocols, file formats, languages. ServiceMix, Fuse, Mule.
Fuse ESB kernel is based on Karaf, an OSGi based run-time/container
Apache Felix: OSGi framework

Routing Engine: Apache Camel

Apache CXF: Supports to host webservices both SOAP, RESTful ways in Spring DM file or in the blueprint

End points: They could be any resource such as specific folder, Webservice, JMS Queues/Topics


Components: Components offer the interface to technologies. JMS, JDBC, FTP, HTTP and many more technologies such as from third parties like amazon cloud services. They need to be configured once in the application.

Processors:In this Java class need to implement Processor interface and override process(Exchange exchange) method. In the route, by default process() is called.

Beans: POJOs are referred to as Beans here. In the route you need to specify which method to invoke

JMS implementation: using Apache/Fuse MQ on the fly by declaring in the Spring file

Blueprint: ?

DSL: Domain specific language to wire Endpoints with/without Processors

Fuse IDE:  supporting canvas based drag and drop EIPs, wiring them

Fuse ESB:  kernel provides native OS integration, so the the application life cycle is bound to the OS

Apache Karaf: Powerful, light weight, OSGi based runtime container for deploying and managing bundles

Exchange: within the context of the Route, it is the message that flows in the route which could be processed by the Processor or to move it from one endpoint to other

Camel Architecture: from http://camel.apache.org/architecture.html

Camel's run-time system can be included anywhere in the JVM environment, including web container (e.g. Tomcat), JEE application server (e.g. IBM WebSphere AS), OSGi container, or even in the Cloud.

JMS

JMS (specification) stands for Java Messaging Service, which enables Java applications to send and receive messages to and from MoM (Message Oriented Middleware) in an Asynchronous fashion. It means the Receiver at the other end does not need to be present for the Sender to send the message, does not need to wait/check for Receiver to be running. If Receiver is running it means it is listening to the Destination. Destination could be Queue or Topic based upon the messaging model configuration Point to Point(PtP) or Publish/Subscribe (Pub/Sub) models.

PtP model: Upon message being published to the Queue by the Sender, out of N Receivers, it will be consumed by only one Receiver. It is like a race condition for the Receivers to grab that message.

Pub/Sub model: Upon message being published to the Topic by the Sender, all of N Receivers receive the same message. You can visualize it as a message Broadcasting setup.

Note: in model models Sender and Receivers must be registered to the Destinations

Messages are of 5 types that could be sent over in both models: Text, Map, Stream, Object and Byte

Applications of JMS: CRM systems, Inventory control systems, Search applications

Java Class Loaders Notes

Class loaders are hierarchical. Child class loaders ask parent to load the class, if parent is not able to then child loads the class, there by maintaining uniqueness. All classes loaded by parent are accessible to child class loaders, but opposite is not true. Question arised in my mind: Child asked the parent to load the class, but due to some issue, parent was not able to load, so child loads it in the JVM. At some point later parent needs that class and obviously parent cannot see what child class loaders' classes are loaded in JVM, so would the parent too loads that class in the JVM? What happens to the uniqueness of the same class?

See NoClassDefFoundError which also occurs at run-time but was available at compile time, obviously forgot to specify it in run time classpath. ClassNotFoundException occurs also occurs at run-time, but you are loading it explicitly using Class.forName and it is not found in JVM, which you have mentioned it right. So in both cases the class is not found at run-time in JVM.

Technology Stack at the new job

Technology Stack at the new job: Enterprise based Insurance mgt. System. Portland, OR

The project is under development since about 2 yrs, then I joined the project, I am hired to fix the bugs related to the application, so I learn the system and technology involved. -Expectation: fix bugs and become aware of the system during fixes.

Obviously there is a lot of code involved which the other developers have implemented and has been moved on to other projects. Expectation -Just fix them.

Working with current developers, they have rich experience with the system. BSAs work on requirements awa with Quality. Expectation -Work with them

IBM Rational Application Developer 8.1
IBM Websphere 7.x (Cell=5HD0HM1Node01Cell, Profile=was70profile1)
Aqua Data Studio 7.5 (for querying database like toad)
Servlet 2.5
JSP: ??
Tools: hbm2java
Web framework: JSF 2.0??? (facelets included)
JEE 5 specification includes JSF
JSF: Sun Implementation version?
JSF component libraries: RichFaces 3.3.1 (does not includes Ajax4Jsf, but Richfaces 4.x does it)
Facelets
JBoss Seam 2.2 framework
JQuery
Hibernate: 3.1 (includes annotations)
Log4j
ehcache 2.2
Spring 2.5.6
Jconnect3 6.05
Code Repository: CVS
Junit 4.4
Database: Sybase

Maven not yet!! Hopefully they will ask for my help in later phase. Mavenize!!

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?

Whats up with SOAP/JSON/REST?

Let me define them here for you; and put up here the common questions: Which, Why and When to use in a given scenario . . .

What is ESB, EMS, EAI about?

Coming up next . . .

Software parameters

In this blog, I will be trying to list software parameters, features, language(s) support, OS etc, so as to make informed decisions while evaluating a given set of product/frameworks.

Most of times Developers/Architects/Managers/Analysts have to deal with selection of a product/framework which suits the business needs. Currently they would need to approach various sources, successful usage in past/current projects, or simply knowing what companies use in their application development. It would especially help them when they have more than 3 choices and which one to with is not very clear. There will also be times when a selecting version (whether to upgrade) in a given framework.

As I think, one approach is profile based, which is top-down and would list the products directly falling under that profile; the second approach is bottom-up where the user would specify what features he is looking for, so the matching ones would get listed. While it would narrows down the selection, it would also be saving time and efforts.

Note: I am going to try it on a high level, so as to keep focus on modeling an approach, meanwhile if you have any comments, please post them here.

Top-down (Profile based) Approach:


Bottom-up Approach:

Cascading styles -notes in brief

Style classes that start with name only, are overrides to original HTML tags. No need to specify them explicity in code.

Style classes that start with dot(.) followed by name are developer style classes, used with styleClass attribute.

Style classes that start with pound(#) are meant to be used with DIV tags. Traverse pattern works here.

Java is 'Pass by value'

In case of primitive types, the actual value is passed so the changes inside the method won't effect outside.
In case of objects, the memory address is passed by value again, so the changes effect outside the method too, unless the object is newly created inside that method.

-- Here is the test code snippet --

public class Java {
@Override
public int hashCode() {
// TODO Auto-generated method stub
System.out.println(super.hashCode());
return super.hashCode();
}

public static void updatePrimitive(int i) {
i = 999;
System.out.println("inside updatePrimitive " + i);
}

public static void updateString(String s) {
s = "bye";
System.out.println("inside updateString " + s);
}

public static void updateObject(Dto dto) {
dto.setValue("555");
System.out.println("inside updateObject " + dto.getValue());
}

public static void updateObjectNew(Dto dto) {
dto = new Java().new Dto();
dto.setValue("777");
System.out.println("inside updateObjectNew " + dto.getValue());
}

public static void main(String args[]) {
int i = 8;
updatePrimitive(i);
System.out.println("outside updatePrimitive " + i);

String s = "hello";
updateString(s);
System.out.println("outside updateString " + s);

Dto dto = new Java().new Dto();
dto.setValue("666");
updateObject(dto);
System.out.println("outside updateObject " + dto.getValue());

Dto dtoNew = new Java().new Dto();
updateObjectNew(dtoNew);
System.out.println("outside updateObjectNew " + dtoNew.getValue());
}

class Dto {
private String value = "Test1";

/**
* @return the value
*/
public String getValue() {
return value;
}

/**
* @param value the value to set
*/
public void setValue(String value) {
this.value = value;
}
}
}

IT-Categories

.		CATEGORY	AREAS COVERED
.		Web Design	CSS HTML & XHTML Graphic Design Ajax & Scripting Flash Usability Accessibility Inspirations
.		Tools and Methods	IDEs Testing Reporting Modeling Project Mgmt. Version Control Build Automation Agile Issue Tracking
.		Open Source	Apache Linux GNU & FSF Commercial Non-commercial Ideology Legal
.		Languages	C & C++ Javascript Flex & AIR PHP SQL ColdFusion Groovy Ruby
.		Java	Server-side Client-side Mobile Frameworks Persistence Performance
.		Infrastructure	Security Storage Networking Deployment Telecom Hardware Reliability
.		Industry	Humor Trends News Events Opinions Personalities Careers
.		Computer Science	Algorithms Research Education Milestones Computability Queueing Theory Language Syntax/Semantics Cryptography Correctness Proofs Automatic Programming Network Analysis Machine Learning Compilers OS Paging/Scheduling Complexity
.		Software Engineering	Requirements Usability Maintainability Modifiability Safety Portability Estimation Testability Design Patterns Scalability Team Process Architecture Styles
.		Architecture	Blueprints SOA Grid Computing Virtualization Integration Performance Interoperability Patterns	Modularity?
.		.NET & Windows	Visual Studio C-Sharp VB.NET MS-Office Dev Data Access ASP.NET Silverlight Win32 & COM