Spring is here

Oftentimes, software developments transits from being fun to becoming a nightmare. Personally, I have had days when the thought of switching to the Object-Oriented (OO) mode brings chills to my spine. But the truth still remains that being a software developer surpasses every challenge, every stumbling block, every last one of ’em.

When a developer builds that zeal to learn new ways of making application development easy then that developer is well on the narrow path to finding the holy grail of software development.

We live in times when the IDE makes “app-dev” easier for the programmer but this does not come with its cons (which I must say are far less than the pros depending on the IDE in use). Before we get in too deep to this lifestyle, let us pause for a moment and remember the good old days when the grit of a programmer was in the ability to manage a software development process from scratch.

I still remember writing my POJOs and having to manage their dependencies (not forgetting exception handling, garbage collection, memory allocation, et cetera) manually. The days when J2SE 1.4 seemed like the IPad of app-dev. Those days when Sun’s Java Technology made languages like C and C++ appear obsolete and out-dated.

Today, with many thanks to the Apache Software Foundation, we have seen countless repositories jump out with offerings of tools that make the develper’s life easier. I will always remain a loyal friend to the ASF. Those guys made my evolution into a software developer worth every second.

Now, what do we have here? The new kid on the block is Spring.

When I first heard of this kid, I was still playing around in the ASF playground, trying out as much new tools as my concerns would require. You name it, I tried it. I even got my hands dirty on the Bytecode Engineering Library (BCEL) and that API for Faceted Search (can’t remember its name now).

Then, i started seeing some new tagsets pop up in tutorials i read (I love reading developer stuff) which i have never seen before. That’s how it all began.

Spring is a lightweight framework that allows for what is called Inversion of Control. What this means is that instead of me to weave object dependencies into my POJO explicitly using the new keyword, I can specify that at runtime using an xml configuration file that defines the relevant class and load that up using an application context (there are variants of this to suit different application needs).

The Inversion of Control here lies in the loose coupling that takes place when using this approach. There are two sides to the IoC coin; Dependency-Lookup and Dependency-Injection.

Lookup entails checking the Bean Factor(ies) of your application context for the existence and/or definition of a particular class while Injections is the actual request for a class definition from the factory, to be assigned to a property.

The opportunities that this approach brings to application development are many and usual, the core benefactors are the Java Technology Faithfuls. I am very much aware that many developers started out with this lovely, powerful technology and abandoned her when the going got tough.

Now that Spring is here, I expect the exodus from other technologies to Java to be a massive one because I could bet that before other technologies get a grip on this concept and provide such functionality for their developers, the Java Movement will be rolling out another 1st for the Software/Application Development Industry.


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: