I find it hard to believe that there are very few articles online talking about database evolve. To think that database is the lifeblood of many application, and yet, very few seem concerned about efficiently managing different versions of a database… while many manage their database manually through their DBA.

But how can you ensure that:

1. during development, all developers works on the latest database schema to reduce code conflicts?
2. during production roll-out, applications on different servers are compatible and consistent with their respective database schema?

If you are doing this manually, then perhaps its time to reconsider your approach by asking yourself - “Is there a way to automate this?“.

Our solution is one that we’ve used for the past three years and has been very effective. It’s a simple approach with just few Java classes. The concept is to keep track of the database version  from the application and keep the database up to date every time the application starts.

For example, if the database is in version 21 and application is in version 24, then the application will apply evolve scripts 22,23 and 24 to get the database into version 24. It’s a fairly simple concept but saves a lot of coordination effort and headache.

I’m posting below the snippets of database evolve we have. You can find the complete set of codes in Open-tides(http://code.google.com/p/open-tides/).

Below is the DBEvolve interface that should be extended by all evolve scripts. The evolve scripts contain SQL scripts to update the database from the previous version to the current script’s version.

public interface DBEvolve {
	/**
	 * Actual database evolve script operations.
	 */
	@Transactional
	public void execute();
	/**
	 * Returns the description of evolve script.
	 * @return
	 */
	public String getDescription();
	/**
	 * Returns the version of this evolve script.
	 * Ensures that execution of evolve script is in proper
	 * sequence.
	 * @return
	 */
	public int getVersion();
}

Below is the main logic that compares the database version with the list of evolve script. evolveList is a collection of DBEvolve to keeps the database updated. It is assumed that evolveList contains a sequential list of evolve scripts.

                // get current db version
		SystemCodes version = systemCodesDAO.loadBySystemCodesByKey("DB_VERSION");
		if (version==null) {
			// no version available yet, lets create one
			version = new SystemCodes();
			version.setKey("DB_VERSION");
			version.setNumberValue(0l);
			systemCodesDAO.saveEntityModel(version);
		}

		// skip evolve if there is nothing in the evolve list
		if (evolveList.isEmpty()) {
			_log.info("No evolve scripts found.");
			return;
		}

		// sort the evolve list
		Collections.sort(evolveList, new VersionComparator());
		// check for duplicate version numbers
		for (int i=0; i<(evolveList.size()-1); i++) {
			if (evolveList.get(i).getVersion() == evolveList.get(i+1).getVersion()) {
				// we have a duplicate version... exit
				throw new InvalidImplementationException(
						"Duplicate version number [" + evolveList.get(i).getVersion() +
						"] detected on evolve script for ” +
						evolveList.get(i).getClass().getName() +
						” and ” + evolveList.get(i+1).getClass().getName());
			}
		}

		// get number of latest evolve script
		int currVersion   = version.getNumberValue().intValue();
		int latestVersion = evolveList.get(evolveList.size()-1).getVersion();

		if (currVersion>=latestVersion) {
			_log.info(”Database is updated at version ” + currVersion);
			return;
		} else {
			_log.info(”Updating database from version ” + currVersion +” to version ” + latestVersion );
		}

		// execute new evolve scripts
		for (DBEvolve evolve:evolveList) {
			if (evolve.getVersion() > currVersion) {
				// let’s execute this evolve script
				_log.info(”Executing evolve version ["+evolve.getVersion()+"] - “+evolve.getDescription());
				evolve.execute();
				// if successful, update current db version
				version.setNumberValue(new Long(evolve.getVersion()));
				systemCodesDAO.saveEntityModel(version);
				_log.info(”Success.”);
			}
		}
		// as precaution let’s update db version again
		version.setNumberValue(new Long(latestVersion));
		systemCodesDAO.saveEntityModel(version);

		_log.info(”Database is now updated to version “+latestVersion);
	}

A few more things to note:

1. The snippet uses Spring and Hibernate. The main evolve should be under Spring transaction to ensure proper rollback in case of failed updates.
2. When application failed to update, it should not start-up to alert the developer of the failure.
3. Due to its simplicity, the code above does not support multiple branches of application and database.

After experiencing a number of production roll-outs, on both blade and rack mounted servers, I began to think about the advantages of one over the other. In general, blade servers sounded like a better approach, but it appears to be more of a marketing hype than reality. I’m not a hardware or infrastructure expert, but my comments are based on my experience in rolling out enterprise applications to various organizations and below are some of my thoughts about blade servers.

1. Blade servers are more expensive. To setup a blade server, you’ll need to purchase a chassis. The price of the chassis alone is already comparable to 2 rack mounted servers. On the average, the price of blade server setup is about 20%-30% higher than a comparable rack mounted server setup. Unless of course, you get to fill-up the entire chassis with 14 blades.

2. Blade servers are less powerful. Processor configurations on blade servers are less powerful than their rack-mounted counterparts. How much processor can you really put into that small form factor? Blade servers are also known for smaller disk capacity because its designed to use SAN storage.

3. Blade servers are not fail-safe. Contrary to the popular belief, blade servers are not fully-redundant (at least the once I’ve seen). Each blade connects to a blade controller which is a single point of failure, if that controller fails, then all blade fails. Some chassis also uses a single power supply, thereby - another single point of failure.

4. Blade servers cannot be super computers. No you cannot combine multiple blades and make them into one single super computer. At least not without the right software. But with the right software, you can also achieve the same on rack mounted servers.

5. Virtualization is not only for blade server. Virtualization can also be set-up on multiple rack servers. Virtualization is a software-based technology and is not hardware dependent. Blade servers + Virtualization is a fuzz.

6. Blade servers are restrictive. Since blade technologies differ from vendor to vendor, adding new processors require purchase of blades from the same vendor. You are even restricted within the blade model supported by the chassis.

Bottom-line: I had high expectations on blade servers and got disappointed with the results. Get your facts straight from the technical merits of using blade servers than listening to the marketing hype presented by that salesperson in a nice suit.

Considered as an essential resource for JavaScript programmers. O’Reilly’s JavaScript: The Definitive Guide 5th edition is one of the books to look for when it comes to JavaScript.

As good as the introduction sounds, the book is unfriendly to those who are unfamiliar with programming. But, is a good book to those who know programming but is new to JavaScript. The book is formatted to suit reference use, it is divided into 4 parts. The first part is dedicated to core JavaScript, which includes primitive datatypes, functions, and objects. The second part discusses Client-Side JavaScript (DOM scripting, Cookies, and Graphics). The third and fourth part contains references for Core and Client-Side JavaScript respectively.

As a student, I always expect my books to be extensive and in-depth. That is why I buy books- to get quality information that you can only get in books. If you agree with me, then this is the book you’re looking for. The book’s content is extensive. It covers almost everything that you need to know about JavaScript. Explanation is also good, since it explains the inner workings of JavaScript.

One of the complaints I have about the book is its lack of examples. Most of the programming books I have read had sufficient examples that served as guidelines for syntax and structure. Having few examples, the book relies mostly on explanation to discuss JavaScript elements. It will really help if you have background in Java or C, since JavaScript syntax is similar to them.

If you are already familiar with the programming languages mentioned above, you might want to skim over the first part of the book. The first part is a lengthy discussion of the different core JavaScript components, which most should be familiar to you (if you are familiar with Java or C). Otherwise, if you are inexperienced in Java or C, it is recommended that you read through the first part of the book since these are essential to learning JavaScript.

Due to a wide array of different web browsers (each with different versions) developed by different groups, incompatibility of JavaScript elements became an issue. It required JavaScript books to be able to pinpoint which JavaScript element works in which browser and of what version. The author responds to this issue by mentioning in which version of JavaScript and EcmaScript would a specific bit of code work. Complementing this method of explanation is a paragraph in the introduction chapter in which the author mentions what version of JavaScript (or EcmaScript) works on what version of a web browser.

Bottom line: a one of a kind book that is worth reading for those who want to learn JavaScript. But, like any book, it also has flaws. With that said, I give the book 4 out of 5 stars.

The MySQL 5.0 Certification Study Guide is a must-read for individuals interested in obtaining MySQL certifications. It is designed to get you that title that you want. Currently, MySQL offers 2 certification titles — the MySQL Developer Certification and the MySQL Database Administrator Certification.

What gives the book authority? Well, the book is authored by Paul DuBois, Stefan Hinz, and Carsten Pedersen. Paul is a member of the MySQL documentation team and one of the leading authors on MySQL books. On the other hand, Stefan is the MySQL documentation lead and Carsten is MySQL AB’s certification manager. Coincidence that people from MySQL wrote a study guide for their exams? I think not.

The book is divided into 4 parts. Each part contains topics for an exam. Examinees need only to read content that their exams require. Since each title requires you to pass 2 exams you will need to read 2 parts (4 parts if you want both titles). Here’s what you can find in the book:

• Details about the exams
• Data Types
• Tables and Indexes
• Querying for data, SQL expressions
• Joins and subqueries
• Stored procedures and functions
• Table maintenance
• Data backup and recovery methods
• Optimizing queries, databases, and the server

The book comes with a CD (if you purchased the printed version) that contains exercises and a world.sql file which contains the database used for the exercises. It also contains a sufficient amount of examples to aid in understanding queries.

After you hang your certificate on the wall, use the book for reference. Although the book is not intended for reference use, it still makes a very good one. It is also quite useful for individuals who don’t plan on taking the certification exams, but desires to learn about MySQL.

Overall, the book is technically accurate, easy to understand, and the topics are well organized. I give it 4 out of 5 stars!

With the growing projects, we’ve decided to upgrade our test servers to a production grade server and setup virtual machines within the server. This move really makes sense because instead of allocating a workstation for each project as test machine, we are cutting it down into one server with multiple test VMs.

At the time of this writing, there are no official documentation on Lucid Lynx yet. There are a couple of variations on the configuration as compared to Ubuntu 9.10. This setup guide is to configure a KVM on Ubuntu Server and management of the VMs is done remotely from another machine running Ubuntu Desktop.

So, here is the step-by-step guide:

STEP #1: Install lib-virt package.

sudo apt-get install kvm libvirt-bin

STEP #2: Create user to manage lib-virt.

sudo adduser $USER libvirtd

where $USER is the username who will perform VM management.

STEP #3: Install bridge utilities.

sudo apt-get install bridge-utils

STEP #4: Configure network to bridge setup.

Edit /etc/network/interfaces and add the following (assumes dhcp bridge):

auto virbr1
iface virbr1 inet dhcp
bridge_ports eth0
bridge_fd 9
bridge_hello 2
bridge_maxage 12
bridge_stp off

STEP #5: Restart networking service.

sudo /etc/init.d/networking restart

If bridge is properly configured you should still be able to connect to any external network. (e.g. ping www.google.com). Once this work, proceed to Ubuntu Desktop to create the VM guests.

STEP #6: Install Virtual Machine Manager (on Ubuntu Desktop machine).

sudo apt-get install virt-manager

STEP #7: Invoke virt-manager and connect to Ubuntu Server.

virt-manager -c qemu+ssh://<ubuntu_server>/system

where <ubuntu_server> is hostname or IP address of the server.

STEP #8: Create the Guest VM image. Virtual Machine Manager provides a GUI to easily create an image. Just right-click on the server and select “New”. You will then be prompted step-by-step on the variables (e.g. # of processors, memory, etc.) needed to be configured for your VM.

STEP #9: Install the Guest VM OS. Use your regular CD/DVD installer or iso image to install the operating system on the VM. In my case, we use Ubuntu Server and Ubuntu Desktop on the guest VMs.

STEP #10: Change guest network connection to use pre-configured bridge. VMM does not have the option to configure bridge network. To setup the bridge, manually change the configuration file (xml) from libvirt. On Ubuntu Server, edit the xml configuration file under /etc/libvirt/qemu by changing the network portion to:

<interface type='bridge'>
<source bridge='virbr0'/>
</interface>

STEP #11: Restart VM. Upon restart, you should be able to access external network and VM is accessible from external network. On Ubuntu guests, the network device is found as eth3 and you may need to enable eth3 on /etc/network/interfaces.

That’s it. You can repeat steps (#8-#11) to setup additional guest VMs.

Ever seen a Java book with graphical images and humorous text on every page? You may think that it’s not worth reading. If so, then you’re wrong! Head First Java 2nd Edition is one of the most fun and motivating Java books you’ll ever find. The book is loaded with images from some 50’s television show with speech bubbles containing humorous text. But, don’t overlook it’s content. The book delivers content that is technically accurate and easy to understand. So, if you’re the type of person who hates boring Java programming classes, but still wants to learn Java, then this book is for you.

Most programmers start their careers doing procedural programming. That is why most also have trouble understanding OOP concepts. Head first addresses that problem by giving readers clear distinctions between procedural and object-oriented programming. Another unique feature of the book is that it gives a lot of analogies about OOP concepts that makes OOP easy to understand.

Here are some of the book’s contents you might be interested in:

• OOP (of course)

• Creating graphical user interfaces (GUI)

• Using the Java API

• Exception handling

• Sorting data structures

• Serializing and deserializing objects (writing to a text file)

• Creating network applications (create a chat client)

OOP is discussed in the earlier parts of the book since you’ll be needing most of its concepts for other chapters like creating graphical user interfaces. You’ll need inheritance (which is an OOP concept) to implement a listener before a single button can even work on your GUI.

In a classroom environment most students will have one or two questions about the lesson. That is why the book includes exercises and “There are no dumb questions” sections after every chapter. Basically, the exercises are activities for the readers. On the other hand, the “There are no dumb questions” section answers the frequently asked questions that readers will have on every chapter. With that said, head first is definitely a book for beginners. But, people with absolutely no background in programming (including those with only HTML background) should not directly learn from the book. Learn basic programming first before proceeding to tackle Head First Java.

]]> http://www.ideyatech.com/2010/05/book-review-head-first-java-2nd-edition/feed/ http://www.ideyatech.com/2010/04/introduction-to-java-content-repository-and-apache-jackrabbit/ http://www.ideyatech.com/2010/04/introduction-to-java-content-repository-and-apache-jackrabbit/#comments Tue, 13 Apr 2010 05:29:29 +0000 Erickson Javines http://www.ideyatech.com/?p=258 With the growing demand in integrating content like photos, music, videos & office docs into business & web applications, we need a content management system that is rich in features, flexible & easy to learn. The Java Community Process developed a solution to this trend – the JSR-170 & JSR-283, also known as the Java Content Repository (JCR) API.]]>

With the growing demand in integrating content like photos, music, videos and office documents into business and web applications, we need a content management system that is rich in features, flexible and easy to learn. The Java Community Process developed a solution to this trend – the JSR-170 and JSR-283, also known as the Java Content Repository (JCR) API.

The JCR specification provides a unified interface that different vendors can implement to meet the needs of a content management system. Application developers, on the other hand, are saved from learning different propriety APIs, thus, reducing time-to-market. They just need to learn one API that is compatible with any JSR-170/283 compliant repository. This framework is not only vendor neutral. It is also not tied to any particular underlying architecture. The back-end data storage could be a file system, a WEBDAV repository, an XML-backed system or an SQL-based database. In addition to flexibility, the Java Content Repository has a lot more features to offer.

A content repository is like a fusion of a database and a file system. Among the valuable features of this integration are:

• support for both structured and unstructured content

• hierarchical design

• SQL and/or XPath query

• access control

• locking

• full-text search

• versioning

Everything stored in the repository is managed as NODES and PROPERTIES. For example, in blog repository, we could say that each node of blog entry must have properties like title, author, text article, and file attachments (photo/video). The JCR API has several pre-defined node types like “nt:folder”, “nt:file”, and “nt:unstructured” but developers can also define their custom node types.

A lot of JCR-compliant repositories are already available in the market. Among them are Day CRX, IBM CM, Oracle XML DB, Alfresco ECM, and Apache Jackrabbit. Let’s explore what Apache Jackrabbit has to offer.

Apache Jackrabbit

<!– @page { margin: 2cm } P { margin-bottom: 0.21cm } –>Apache Jackrabbit is a fully conforming implementation of the Java Content Repository. It complies with level 1 and 2 of JCR and adds more advanced features. Shown below are the features supported by each level:

To start developing applications with Apache Jackrabbit, you may download the Jackrabbit web application module from the Apache Downloads, get the JCR specification and javax.jcr package, study the JCR API and use the following model for your repository application:

For more information, you may visit the Apache Jackrabbit site at http://jackrabbit.apache.org/

If there’s one word to describe how people from this side of the world is currently feeling about the weather — I bet cool, freezing or cold will be such a surprise to hear cause summer in the Philippines has always been crazy HOT! Actually, with global warming and all, “crazy hot” is even an understatment.

It’s all good though cause brutal sunny days is definitely so much better than gloomy rainy ones. So while the scorching heat is in full effect we took advantage, have a lil break and what else could be much more fun than hitting the blue seas far away from the city!

This year, the company had its annual summer outing down south at Stilts Calatagan Beach Resort located in Calatagan, Batangas. It’s a predominantly white sand, blue water resort 3-4 hours away from the city. Trip’s a lil exhausting, really, but the awesome scenery, the soothing scent of the ocean, everything — it’s all super worth it. Actually, reliving the memories as I’m writing this blog kind of brings back the relaxing feeling I got from the whole getaway. T’was a lot of fun! See what went down from our over night escapade. Enjoy!

There’s this CSS trick I came across a couple of years ago that never seize to amaze me. It’s the use of two position attributes to control elements within a defined boundary. It is, by far, one of the most lucrative piece of CSS information that I get to apply in so many design situations and actually, if you’re just starting to learn about CSS, this is going to take you far.

To better understand how this trick works, let us use it an actual design scenario, for example — creating boxes with rounded corners.

Long before people knew about CSS3, designers have already been fond of using boxes with rounded corners. Nowadays, creating these have been relatively easy especially with the aid of CSS3, particularly, the –moz-border-radius or –webkit-border properties.

Handy as it may seem, some CSS3 properties such as what I’ve just mentioned tend to have cross-browser compatibility limitations. It’s inevitable. Finding alternative ways to get around it is the only thing we can do.

So if you ask me, using images maneuvered with few CSS position properties are still the less hassle way of dealing with boxes with rounded corners.

Here’s what we’re trying to produce.

Basically, it’s a green box with 4 rounded corners with some text inside. And here’s how we go about it.

I. Producing the Rounded Corner Images

Normally, I’ll slice square images of the 4 rounded corners in Adobe Photoshop and export it as image files. Here are links to my sample images:

• Top-Left Corner
• Top-Right Corner
• Bottom-Left Corner
• Bottom-Right Corner

II. The HTML Code

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus rhoncus iaculis est et convallis. Cras sed turpis a ligula blandit tempus. Maecenas orci nibh, dapibus ac iaculis et, porta nec ipsum. Praesent sollicitudin, nisi non fringilla venenatis, ligula quam molestie felis, eu hendrerit leo sem non lectus. Sed semper malesuada pharetra. In eu ipsum a nisi tristique suscipit. Pellentesque hendrerit ornare mi in feugiat.

What we did here was to create a containing div element and under it are the 4 rounded corner images in its own div that we’ve given class names of TL, TR, BL & BR respectively. Then there’s the paragraph that should be seen inside the box.

III. The CSS Code

.box { position: relative; border: solid 1px #7cbb30; }
.TL, .TR, .BL, .BR { position: absolute; }
.TL { top: 0; left: 0; }
.TR { top: 0; right: 0; }
.BL { bottom: 0; left: 0; }
.BR { bottom: 0; right: 0; }

Using CSS, we are tying to manipulate where the different elements should be located. This is where THE trick should come in.

The first line was for the containing div of our box. The position: relative; that we’ve given for it will set the boundaries as to where our images can go. It limits the extent on how far everything inside it will be positioned. Then the border properties were given to make it look like an actual box.

The second line was for our 4 images. The position: absolute; that we’ve given for it will position the images relative to our containing box. With the help of directional attributes, it controls where exactly inside the box these images should be positioned.

Then the succeeding lines are just directional attributes that dictate which corners should our images go.

The combination of the two position attributes in creating boundaries and maneuvering elements within that boundary are very crucial in this example. Understanding how they work together is one CSS trick that you’ll find very useful in a lot of situations.

We’ve seen effective use of dashboards with various applications. Dashboard shows the summary of the entire system operations in just one page. In addition, they make your application look cool and more interactive with use of graphs and charts.

So now its your turn to create a dashboard for your killer app, here are some tips to make dashboards more effective:

Do’s:

• Show only relevant information for the user. Dashboards should be customized specific to the user.
• Highlight priority and overdue tasks. Use colors to represent the importance and urgency. For example, red is commonly associated with “High” priority while gray is to “Low”.
• Use graphical representation (i.e. bar graph, pie charts) as summary statistics. Display a pie chart to show breakdown by category or bar graph to display performance.
• Do consider use of cache. Dashboards are heavy on database queries. So, applying caching techniques would reduce performance hits. For example, if your dashboard is showing total number of issues reported yesterday, there is no point of executing the query every time the dashboard page is loaded.

Dont’s:

• Do not prompt for action. Avoid asking user to do a task on the dashboard. While it may seem appealing to the user, it actually distracts the user from looking at the overall picture. If really unavoidable, try to show the summary first and prompt for action only after clicking on “Show Details” button.
• Do not list down records one by one. Considering displaying only “Last 10 Messages” instead of “All Unread Messages”. Otherwise, your dashboard will bombarded with long lists of stale data. Alternatively, display only the count of all the records (e.g. You have 56 unread messages).
• Don’t overdo it. Remember that dashboard are heavy on database query so display only important and relevant data.

December 11, 2009 marks the day that we held our company Christmas Party. This year, the annual festivity was celebrated unlike any other as we hit it — Luau style!

The night started with a little feast actually make that the most amazing buffet meal we had for the said occasion. It was such a hit!

Then the program began and it has not been more exciting than ever. It was filled with a lot of blutterbungs which include ginormous set of raffle goodies, exalting party games and of course, the very animated employee performances!

Here are some of the out takes:

In the end, everyone went home exhausted but in better spirit as another event brought the company together in this season of joy, peace, love and happiness. Happy Holidays!

PHOTOS BY: Neil Namoro

Following the events of Ondoy and Pepeng a few months ago, and in celebration of the spirit of Christmas, SQME and Ideyatech decided to do something different by hosting an activity that would be socially relevant and fulfilling at the same time. After careful consideration of possible institutions to partner with, Pangarap Shelter Foundation was chosen as the sponsor institution for this event.

Along with two (2) Hands-On Manila volunteers (Leo Cabasag and Ate Cecill Artates), 37 volunteers from SQME, Ideyatech and friends were able to attend this outreach program to share themselves with the boys from Pangarap.

The Pangarap boys (along with girls housed by Pangarap Foundation at an apartment nearby) wowed us with different performances from singing to rapping to dancing. They awed us with an interpretive dance entitled “Who Am I”, opening the event with an uplifting song and dance number.

The Pangarap Choir rendered a very enlightening song

A sibling pair showcased their talent in rap and beatboxing

Two groups of Pangarap boys called the Gimikeros and the Javawakees exhibited their talents in dancing

And the Pangarap girls also showed that they can groove like the boys.

But probably the most enjoyable part of this event was the part where the volunteers and the boys joined in to play some fun games. The Longest Line was great to start off the games since it got everyone hyped up!

The Sack Race game even made things more exciting for everyone, as a Pangarap Foundation kid is partnered with a volunteer to run a three-legged sack race.

The Calamansi Relay proved to be harder than it seems, especially that if the calamansi fell, you have to go back to the start.

The Bring Me game didn’t sell much because people were already tired from the games. But we were able to give away a lot of goodies, towels and tumblers in this game.

We capped off the games with a few minutes of sharing and interaction with the boys. This became one of the major highlights of the event for the volunteers, as most of them say they were humbled by the stories of the kids.

Before the sharing session came to a close, Raffy, formerly sponsored and housed by the Pangarap Shelter Foundation, spoke of his own success story as a form of inspiration for the kids and for us, volunteers, as well.

Lunch came soon after, complete with ice cream!

Our outreach program to Pangarap Shelter Foundation ended with a tour of the place, especially at their candle workshop.

Over-all, this Outreach Program proved to be a very fulfilling and inspiring activity for everyone. We shared ourselves, never expecting that they’d be the one sharing more of themselves with us.

It’s been 2 weeks since I installed Karmic Koala, the latest version of Ubuntu. After having to use Windows Vista and Mac Leopard, here are some of my reviews and opinions on Karmic Koala:

INSTALLATION - 7/10:

• Installation is easy. It has the graphical interface to prompt user at every step of the way. You can either install within your existing Windows partition or install Karmic in its own partition.
• The most embarassing problem you’ll encounter in Ubuntu is lack of device drivers. This is due to lack of support from hardware manufacturers to write drivers for Linux. But once you got the device drivers right, everything else will be better. Luckily, on my VAIO VGN-SR35G, only the internal mic was not supported.
• Installing applications is quite easy as well. There is a “Synaptics package manager” that takes care of listing, installing and updating your application… provided there is one available for Linux.

PERFORMANCE - 10/10:

• The speed and response time of Karmic is lightning fast. Opening applications is as fast as blink of an eye. Compared to Vista, Karmic wins by 10,000 miles. Compared to Leopard, Karmic still wins by a few miles.
• Startup and shutdown time is amazing. I’ve compared start-up time with Vista and Leopard side-by-side, and Karmic is faster by 10 - 30 secs.

USABILITY - 9/10:

• Interestingly, I find the organization of files and programs of Karmic better than Mac’s OS. Documents are easy to find using the “Places” menu. Programs are automatically organized into groups within the “Application” menu. The toolbars are easy to configure as well.
• There is no clutter in your desktop because programs can be dragged into various “spaces”. So, you can easily switch from your “office space” to “media space” easily.
• The visual effects are astonishing. In Compiz, you can use the burn effect when closing your window and even 3D cube effects upon switching workspace.

APPLICATIONS - 6/10:

• Despite lack of commercial software for Linux, I find most of my daily needs supported in Ubuntu. Open office is acceptable in 90% of the time.
• Eclipse, MySQL, Tomcat and other Java development tools are well supported.
• Installing Eclipse is a bit tricky. There are a couple of reported bugs if you are installing from the tar.gz file while the Synaptics package manager supports only core Eclipse modules. My solution is to install Eclipse via Synaptics and override the plug-ins with the files from the J2EE version of Eclipse.

RELIABILITY / SECURITY - 10/10:

• We all know that Linux security is topnotch. Thanks Mr. Torwalds!
• If your devices are supported, expect the best reliability of your applications.

CONCLUSION:

Unfortunately, not all users have the patience and experience to setup an Operating System. But for the lucky ones, Karmic Koala is a great operating system… For me, its better than Mac Leopard and Windows Vista. If computer manufacturers would adopt to supporting Ubuntu on their hardware, this could certainly change the perspective in computing. With my recent experience, I think we can move our organization closer towards adopting a full open-source system on our software development needs.

October 21, 2009 — This date marks the day that Ideyatech celebrated another anniversary. While it felt as if the last was just a few months back, the company has just gone older and it’s been an exciting development for everyone.

This year, the annual muster was held at Max’s Restaurant in Megamall. It started with a little discussion about administrative matters succeeded by project summaries and accomplishment reports. In general, the company took pride in: (1) being prolific in the aspect of accomplishing previously set goals especially in the fields of building/strengthening the companies Software Development Processes, (2) by being significantly relevant in surviving an economically strenous year that feigned businesses globally and (3) focusing on product development by releasing Open-tides version 0.4 and significant documentation updates, E-recruitment Tool, as well as continuous research and development of products that is currently being developed.

Moving forward, Ideyatech strives to make its presence felt in the industry. The company is also very optimistic in acquiring new skilled individuals that will help fortify in strengthening the company’s services and product lines.

In the end, it has been an illustrious time for everyone to catch up and be on the same page. While it felt like the past year went by so fast, it was indeed, an exciting development for everyone.

If you want to know more about Ideyatech, you can find more information on our company page.

When developing an application in a web server environment, the ease of use and startup time of the application are crucial elements for best performance. Due to this, the Hot Code Replace (HCR) debugging technique was developed to “facilitate experimental development and to foster iterative trial-and-error coding,” effectively improving application development performance. In brief, HCR allows you to “start a debugging session on a given runtime workbench and change a Java file in your development workbench, and the debugger will replace the code in the receiving VM while it is running.” In essence, no restart is needed.

However, when changing either class signatures or instance variables, HCR will not work; a restart is required for changes to take effect. “Context Reloading”, necessary for changes on configuration or property files to take effect, also requires a restart.

This is where problems arise. The need to restart the application consumes too much time. In my experience, one of my projects takes an average of three (3) minutes to restart. Restarting ten (10) times already uses up 30 minutes of valuable development time.

My current development environment: Mac OS X 10.4.11, Maven 2, Struts 1, Spring 2.0, Hibernate 3, Eclipse Galileo

The following measures below were taken to improve performance. This can serve as guidelines for the enhancement of server startup time.

1. Disable Xdoclet Maven Plugin (for hbm generation) when not needed. This decreased startup time from 2:59 to 2:32.

2. Lazily instantiate beans during development. A major bottleneck in application startup occurs during Spring pre-instantiation of singletons (our project has 677 beans defined in application context) in factory. Set Spring’s “default-lazy-init” to “true”. Startup time decreased from 2:32 to 1:58.

3. Upgrade project execution environment to the latest version of JVM. I upgraded the default Mac OS X default JVM 1.5 to SoyLatte JDK 6, further decreasing startup time from 1:58 to 1:02.

4. Use embedded Jetty instead of Maven Jetty Plug-in or Eclipse Jetty Adapter Plug-in when starting the web server. This lessened startup time even further, from 1:02 to 0:37.

The measures described above effectively shortened the average startup time from 2:59 to 0:37!

So if you want to boost your productivity, try out the guides set above! These tips will definitely make startup time faster and help improve your application development performance.

The property innerHTML are read-only for the following html objects:

COL, COLGROUP, FRAMESET, HEAD, HTML, STYLE, TABLE, TBODY, TFOOT, THEAD, TITLE, TR

and trying to update the value of their innerHTML property will give you ‘unknown runtime error’ in IE browser.

Though creating child elements by DOM method can resolve this, it’s still not a good idea to add all the elements needed dynamically if we have big chunks of it - forms, labels, lots of input, buttons plus their properties (class, colSpan, etc..). And more problems if the new innerHTML value must have taglibs like and . Also, creating div inside a table has broken layout in firefox. So innerHTML will still be the best solution (well it’s still up to you and the situation).

So here’s the situation: We want to replace the contents of our tr

innerHTML not working in IE.



    

Solution:

1. First we have to get the div element, the read-only element (tr) and the new innerHTML value.

2. We’ll get the innerHTML of our div - this is the oldHTML.

3. We’ll use the method .replace([regex pattern], [new value]) to find and replace the tr element’s value from the oldHTML with the new value - so this is now our newHTML

4. Now, that we have the updated value, we will place it in the div element by using .innerHTML = newHTML.

Javascript:

Open-Tides Version 0.4, the latest build of the Open-Tides framework, improves developer’s productivity as much as 4x by introducing a complete set of code generation tools through the use of model annotations.

Ideyatech is excited to release the latest version of Open-Tides, version 0.4. This version contains the following:

1. Automatic Code Generation - Open-Tides automatically generates the dao, service, controller and jsp pages of your beans.
   • Faster Development. You do not have to spend a lot of time creating the dao, service, controller and jsp pages of your beans–they are automatically created for you! To create an application, just create the beans, add the annotations, and then generate the build!
   • Easier Development. Apart from being able to develop code faster, code development becomes easier! All you need to worry about is creating the beans and understanding the simple annotations used by Open-Tides!
   • Consistent Code. Code naming convention and structure is assured of consistency because of the automatic generation of code. Whether the project beans are created by singular or multiple developers, all code developed via the Open-Tides framework have one generic naming convention and coding structure.
   • Reduced Errors. Syntax errors and errors caused by incomplete code or mistyped code are  lessened because of the several manual entry of code is done automatically already.

   
   

2. JavaDocs API - Documentation is available to aid in the use of annotations as used and implemented by Open-Tides.
   • The javadocs contains the different annotations, their optional elements and a few examples on how to use them. Including this in your project directory structure enables you to access help on annotations just like any other javadocs api.
   • In addition to this javadocs, there are other .pdf tutorial guides found on the link below to assist you in your code development.

Check out the source codes, latest build and other related files here: http://code.google.com/p/open-tides/

While there are a number of resources on the net talking about converting images to tiff in Java using JAI, I wasn’t able to come across one that works on a Mac. JAI is a separate download from the JDK and unfortunately, there are no mac version of JAI that can be downloaded from the Sun site.

Upon reviewing the jar files included in OSX, I found jai_codec.jar and jai_core.jar in my libraries. So, if you have those libraries, you should be able to get JAI to work and convert your images to tiff.

Here’s the code that I’ve successfully used to convert any image to tiff.

public static void convertToTiff(String inputFile, String outputFile) {
	try {
		TIFFEncodeParam param = new TIFFEncodeParam();
		param.setCompression(TIFFEncodeParam.COMPRESSION_NONE);
		param.setLittleEndian(false); // Intel

		File outFile = new File(outputFile);
		FileUtil.createDirectory(outFile.getParentFile());
		OutputStream ios = new BufferedOutputStream(
	new FileOutputStream(outFile));
    		ImageEncoder enc = ImageCodec.createImageEncoder("tiff", ios, param);
		RenderedOp src = JAI.create("fileload", inputFile);	

	      ColorConvertOp filterObj = new ColorConvertOp(
	            ColorSpace.getInstance(ColorSpace.CS_sRGB),null);
	    //Apply the color filter and return the result.
	    BufferedImage dst = new
BufferedImage(src.getWidth(),src.getHeight(),BufferedImage.TYPE_3BYTE_BGR);
	    filterObj.filter(src.getAsBufferedImage(),dst);

	    // save the output file
		enc.encode(dst);
		ios.close();
	} catch (Exception e) {
		_log.error("Failed to create output tiff file.",e);
		throw new SystemException("Failed to create output tiff file.",e);
	}
}

The example above uses no compression and converts the image to 24bits. You may change the parameters as needed.

I’m a Spring fan, but I decided not to use Spring in our recent project because I don’t want bulky jar files in our application but I wanted to have spring-like configuration. So, I’ve decided to write my own dependency injection code in less than 50 lines of code!!

To simplify dependency injection, I’ve taken out most of the advanced configuration features and keep the implementation to bare bones. In summary, the code only performs dependency injection to make your application configurable from external property files. The result is a small and lightweight dependency injection framework that makes your application configurable via property files.

Of course, short and simple means less features. Some of the caveats from this implementation includes:

• Assumes parameters in your DI methods is String. You will need to convert the parameter to the appropriate datatype in your code.
• Assumes your class for injection extends the base Injectable class
• Dependency injection is done using property files.

Below the main method for dependency injection. But I’ve also attached a complete set of codes and example.

public Injectable get(String id) {
	try {
		id = id.trim();
		String objectClassName = configPersistence.getSetting(id + ".class");
		if (StringUtil.isEmpty(objectClassName))
			throw new ConfigurationException(
						"Cannot find object class for id ["+id+"].”);
		Class objectClass = Class.forName(objectClassName);

		// create new object
		if (!Injectable.class.isAssignableFrom(objectClass))
			throw new ConfigurationException(objectClass.getName() +
					” is not an instance of Injectable.”);
		Constructor cxr = objectClass.getConstructor(String.class);
		Injectable object =  cxr.newInstance(id);
		// add reference to this object factory
		Field factory = Injectable.class.getDeclaredField(”factory”);
		factory.setAccessible(true);
		factory.set(object, this);
		// let’s populate the object’s attributes
		Map attributes = configPersistence.findSettings(id);
		for (String key:attributes.keySet()) {
			// get the method name
			String methodName = key.substring(key.lastIndexOf(”.”)+1);
			// ignore class definition
			if (”class”.equals(methodName)) continue;
			// find a setter method for this attribute
			try {
				Method method = objectClass.getMethod(methodName, String.class);
				method.invoke(object,(String)attributes.get(key));
			} catch (NoSuchMethodException nsme) {
				throw new ConfigurationException(”Method ["+methodName+
				"] not found for class ["+objectClass.getSimpleName()+".]“, nsme);
			} catch (IllegalArgumentException iae) {
				throw new ConfigurationException(”Method ["+methodName+
				"] invalid for class ["+objectClass.getSimpleName()+"].”,iae);
			} catch (Exception e) {
				throw new ConfigurationException(”Failed to invoke ["+
				methodName+"] for class ["+objectClass.getSimpleName()+"].”,e);
			}
			}
		return object;
	} catch (ConfigurationException ce) {
		throw ce;
	} catch (Exception ex) {
		ex.printStackTrace();
	}
}

There are 2 dependency files needed in this example. They are merely helper classes to enforce the rules. You may remove / change them as you please. To keep this blog short, I’m attaching a sample program that includes the files needed. Just run “Sample” application and notice that values in the classes are initialized from the property file called “inject.properties”.

Download sample codes

Enjoy!

Last April 6 and 7, we all took a break from our busy schedules and spent two days to freshen up and relax at Casita de Ana Maria Resort, a private hot spring resort located at Pansol, Laguna, a few kilometers before reaching Los Baños, Laguna. We rented three rooms to fit all 34 of us, and since it was a private resort, we had the whole resort to ourselves.

We arrived at around 3pm and only began to swim as the sun started to set. The night was filled with laughter and fun as we swam and dipped in the pool, played cards (of poker, of pusoy dos, of lucky nine, etc), played mahjong, shared stories, sang our hearts out and partied the night away.

One of our officemates wasn’t able to attend the event. But he still managed to get involved in one way or another:

Now this is what we call Online Presence! ^_^

Two days ago my Macbook failed to startup and I later realized that the hard disk had seized to function. So, to save time for others, I’m sharing my experience with the steps how to save your previous files.

If you are consistently unable to startup your Macbook after 10 minutes of more, considering doing the suggested steps below:

1.) Restart your Macbook and press Apple-V. This will startup your machine in verify mode where start-up sequence is shown on screen. Alternatively, you can try Apple-S for single user mode. If you see message like “unable to read fs block…”, this means that you have bad sectors on your drive.

2.)  If you are unable to proceed due to read failure, try booting from the installation CD. Insert the OSX installation CD, and use “Disk Utility” to diagnose the problem. You may try the “Repair Disk” option and see if that solves your problem.

3.) If the “Repair Disk” failed, try starting up using Target Mode. You will need an extra machine with a firewire cable to do this. See http://support.apple.com/kb/HT1661 for more details. Once target mode is setup, try accessing your drive and proceed to step #7 on how to extract corrupted data.

4.) If target mode failed to read your drive, or you simply don’t have the tools (extra machine, or firewire cable), pull out your hard drive and put it into an HDD enclosure. An HDD enclosure will convert your hard drive into an external drive. You can the plug this enclosure on another machine so you can extract files from it. Proceed to step #7 on how to extract corrupted data.

5.) If you don’t have an extra machine, buy another hard drive. If you have reached this point without successfully recovering your system, you most likely encountered a hardware failure already. So, you’ll have to get a new drive anyway.

6.) Install a new copy of OSX on your machine, and configure everything accordingly. This will be your new home. Once completed, your next concern is how to recover the files from the old drive.

7.) If you are able to access the drive from Finder, then simply copy the files to a new drive.

8.) If you are unable to see the drive from Finder, try using “Disk Utility” again. If you are able to see your drive from Disk Utility, try using a data restoration software. In my case, I used “Data Rescue II”. Initial scans on the drive didn’t show any files for restoration. However, after trying the thorough scan, the files appeared. Thorough scan takes a while to finish, it took me about 4 hours to scan an entire drive of 120Gb. Once you have the file, restore them to your desired location.

That’s it. I hope you won’t need these tips but just in case you do, hope you find these tips useful.

Being a technology outsourcing firm, Ideyatech works with various industries and corporations outside the Philippines. It has always been our observation that while the firm’s address is Pasig City, we are still referred to as “Manila” team due to its being located in the Metro Manila region. I am pretty sure that if our team of Java Development experts were located in, say, Cebu City, we would have been called “Cebu” team, or “Philippines”. Nobody calls us Pasig team, which we actually are, judging by the city where we are located; or as Ortigas team, in reference to the business district where Ideyatech has its offices.

So allow me to give a brief information about Ortigas and the city that plays host to a portion of this dynamic district, Pasig. Basically, the breakdown of our address goes by this simple deduction:

Philippines — Metro Manila (or Manila) — Pasig City — Ortigas

Over the past decade, Pasig City came on its own as a major commercial district in Metro Manila, Philippines, rivaling nearby Makati in business growth, infrastructure, and employment. Workers from nearby cities flock to Ortigas Business Center, Pasig’s main business hub, which hosts contact centers, software development companies, and shopping malls.

Ortigas, where Ideyatech is holding its offices, is strategically located at the intersection of Pasig and two other cities–Mandaluyong and Quezon City. It is bound by three major highways that service the northeast portions of Metro Manila region, namely, EDSA to the west, Ortigas Avenue to the north, and Shaw Boulevard to the south.

Ortigas Center is not an entirely new business enclave. However, although it was developed in the early 1980s, its growth as a major commercial center started with the establishment of three shopping centers on its northern section in the 1990s. It started with SM Megamall, which was at one point the biggest mall in Asia and second only to the Mall of America; then came Robinsons Galleria and Shangri-La Plaza malls. Still, even before these shopping centers came along, Ortigas Center already hosted the corporate headquarters of three major business organizations: the Asian Development Bank, San Miguel Corporation, and the Manila Electric Company. And before I forget, the Philippine Stock Exchange has its home in Ortigas.

Infrastructure development in Ortigas Center grew at a tremendous pace in the mid-‘90s when tech companies and contact centers chose the location for its proximity to the Philippines’ financial center, Makati, and the gamut of modern skyscrapers that now house such companies as HSBC, Convergys, Sykes, and Hewlett-Packard, among many. As each new development paved the way for another, Ortigas now boasts of one of the best telecommunication infrastructure in the Southeast Asian region.

If you want to know more about Ideyatech, you can find more information on our company page.

Last Tuesday, the 24th of March ‘09, me and six of my colleagues from Ideyatech spent a few hours of bowling at Megamall’s Bowling Center. I’ve tallied the scores per team, per game, per person, as found below:

The highest scorer for the night was Julius, in his second game, garnering a score of 156, followed by Chris with a score of 152 in his third game.

The highest average for the night goes to Chris, with a 129-122-152 score to average 134.30, trailed by yours truly, with a 127-113-150 score to average 130.00.

Based on over-all average, team 2 (flip, julius and benjie) won with a total of 1095 and an average of 365 for three games.

Great work guys! Let’s do this again soon!

The pictures are attached below:

We’ve recently discovered a problem in our audit logging facility where Acegi returns a different user other than the actual user. It’s a little hard to replicate because it happens only when multiple users are accessing the system. In summary, audit logs were associated to other users because Acegi SecurityContextHolder is returning incorrect user reference when invoked within a Hibernate interceptor. Our tests showed that retrieving user within the service or DAO layer works correctly but retrieving user from an interceptor may potentially return a different user.

Our implementation is based on recommended audit logging technique as documented by Hibernate here with a couple of extensions. To be exact, here’s an old post about our implementation.

We discovered this problem during the Beta Test stage since there are multiple concurrent users testing the system. To prove that system is misbehaving, we’ve performed the following:

• Create a long running process for User A session. Let the process continue to execute with recording of audit logs.
• Create a new session for User B and do a couple of actions for the user.
• Check audit logs created for process of User A.

Our test results showed that some audit logs for User A process were recorded to User B, specifically during the time when User B performs an action. Apparently, this poses a serious hidden flaw in using Hibernate Interceptor and Acegi SecurityContextHolder for audit logging.

Hibernate Interceptor seems to create a separate thread to perform postFlush and other interceptor functions and Acegi SecurityContextHolder also has its own threading algorithm. In the end, a disconnect of user sessions.

To solve this problem, we resorted to adding a transient variable for the user id in the Auditable entity. The value of user id is populated on the service level because Acegi returns the correct user reference at this time. While this solution may not seem intrusive, I’m happy to say that it solves the concurrency issue.

Nevertheless, I posted this blog as reference to anyone attempting to implement Audit Logging or anyone who has already encountered the same problem. Please post other possible solutions.

Let’s face it: we are in the middle of a recession, and no matter how hard we think otherwise, millions of jobs are at stake, IT projects are restructured, and companies are slashing budgets wherever they can.

But while the current global economic climate does not spell “business as usual,” we all know that business must go on. This is an interesting time if one looks at the state of world economy in glass-half-full way. Everyone is connected to everyone else, thanks to international commerce and technologies that have allowed all of us to carry out business at lightning pace on a global scale.

The celebration of Charles Darwin’s 200th birthday last February 12 brings to mind how even among humans and organizations, the fittest survive. And anybody knows that in a survival-of-the-fittest scenario, it is not necessarily the biggest or the strongest that make it but the smartest and toughest.

In the tech world, survival of the fittest will be the norm at least until after market conditions change and new ways of distributing services at prices the market is willing to pay for comes around. For the meantime, middle-of-the-ground technologies, such as open-source applications, have every chance of surviving this climate. It will not be free, but being significantly cheaper, open-source, as an example, has a foot at the door, thanks to cost reductions that companies are actively pursuing.

Business needs must still be met, but the challenge lies in meeting these needs inexpensively without sacrificing scale and quality. It is why we can argue for the good that this recession will bring to technology, and how technology will sustain many companies until things turn for the better.

While there is very little venture capital that flows into new initiatives, competitive firms are reinventing the way technology is produced, distributed, and consumed. Netbooks are outselling their traditional mobile computing counterparts while SaaS and open-source applications are addressing specific, targeted computing requirements of businesses of any size (hey, everyone is in belt-tightening mode), from product management to enterprise resource planning to content development. Firms are cutting down on business travel costs by adopting virtualization, and so everything that could be done online has a good chance of being relegated to the cyberspace. It will be interesting to see how Java developers—most progenitors of AJAX—will take advantage of the business technology climate, with or without VC backing.

But moving beyond the web sphere, one could only wonder how the lessons of Web 2.0, crowdsourcing, Wikipedia and open source applications will be applied to outsourcing as companies seeking to cut costs ship more projects abroad.

Last January 30, 2009, the three-and-a-half-month-long Enterprise Java Web Development Training Program finally concluded. The second batch of trainees saw the fruits of their intense training with a short graduation ceremony last February 2, where they received their training certificates, and a small merienda treat from Allan.

Congratulations Batch 2 Ideyatech Trainees!

Today earmarks another event in Ideyatech’s history. Today, we announce the release of the third version of Open-tides.

Open-tides is a web application framework contributed by Ideyatech to the open source community. It is a framework that can be used to quickly setup a web application using Spring MVC and JPA. Open-tides’ technology stack includes industry’s leading enterprise tools such as Spring, Spring MVC, Acegi, Quartz, JPA, Hibernate.

Based on actual project statistics, Open-tides boosted productivity of Ideyatech developers for about 218%. Usual project setup time takes about 1 week but with use of Open-tides, project setup takes only 1-2 days. Moreover, creating administration pages have been significantly reduced from 4 days to 1.5 days. This productivity gain helped project teams to focus more on business rules and quality testing rather getting things to work.

“Opentides is the heart of Ideyatech’s success. We’ve used this framework to quickly setup various projects from ground-up… and we would like to share this to the rest of the world. “ as announced by Allan Tan, President/CEO of Ideyatech and Chief Architect of Open-tides. 

Admittedly, Open-tides is still at its infancy and it will take twice the effort and time to get the framework to be accepted by the mass public. Nevertheless, Ideyatech is looking towards improving the framework’s documentation and ease-of-use to promote the tool for public consumption.

Some notable features of the framework include:

• Basic project setup. Open tides gives you base project setup right away. Base setup includes user login and management.
• Built-in security. Integrated with ACEGI Security and pre-configured.
• Support for CRUD pages. Uses JPA/Hibernate for CRUD operations by simply extending pre-built classes.
• Search By Example. CRUD pages includes built-in search criteria and results pagination.
• Audit Logging. Changes to data (who, when, what) are tracked.
• Email notification. Email notifications and alerts are pre-configured.
• Database Evolve. Allows scripted database updates for production roll-out.

Details of the project can be found here: http://code.google.com/p/open-tides/

One prevailing school of thought about SaaS is that while data migration is relatively easy, data integration is a different story entirely. Even as IT budgets stagnate, SaaS is poised to grow by 22.1% this year because of the relative ease of implementing supported projects in small and medium enterprises. But big businesses—such as those in the financial markets—have varying complexities it handles information

Gartner analysts have so far stated the obvious that implementation of SaaS should be based on its value to the entire enterprise and not just to a single business function. Data integration that allow for ease of access to information is where locally hosted systems trump SaaS

According to Gartner’s white paper, “Architecting Information Delivery into SaaS Initiatives,” CIOs and IT leaders should cover data that reside in SaaS applications in their data integration projects, and perhaps more importantly, identify data management and integration requirements to prevent risks that eventually impact the quality of deployment

Engaging a SaaS provider is akin to hiring a group of workers to join one’s technology department. Pre-implementation preparations, such as due diligence reviews and drafting statements of work, takes a certain measure of effort no matter how relatively easy it is to implement applications. This is enough to push the idea of delivering SaaS capabilities to enterprise-wide technology landscape. “The infrastructure environment must cater for extensible use by additional applications, or become integrated as a part of a new system’s infrastructure,” according to the paper, and thus must be a corporate mandate in order to maximize the opportunity that SaaS affords for service buyers

For vendors, access to, and delivery of, corporate information to privileged users throughout the enterprise is an opportunity that they should look at. Gartner believes that buyers should have an “architected approach is provided for, to bring back strategic information to the organization.” Service level agreements should immediately feature integrated information management and delivery, instead of chalking it up as a hidden cost. And by “architected approach,” it should further involve the possibility of interoperability with other applications, platforms, and perhaps partnerships as SaaS implementations mature.

“The reality is that despite SaaS applications functioning as an extension of an enterprise’s IT ecosystem, they often lack assimilation with the information and integration demands of the broader enterprise’s internal applications, and sometimes with other SaaS applications,” according to the study.

In my previous outsourcing partnerships, I noticed that while there was too much emphasis on processes, methodologies, and product quality, “soft” components of the projects and outsourcing relationships were mostly overlooked, if not completely neglected. This is rather ironic because one of the key points that either break or make outsourcing deals is culture.

Cultural differences affect leadership and management, communication and coordination, change management, and team dynamics, which are essential to the success of a project. Just because one partner has been known as culturally dominant does not mean that outsourcing providers already know what it is like to actually work with them.

The success that the Philippines has been enjoying so far has much to do with cultural ties with the west, particularly to the United States, thanks to half a century of American rule, long-standing political and trading ties, and mass media consumption. It probably helps, too, that Filipinos form one of the biggest Asian minority groups in the US.

Language proficiency and cultural parallelisms make the Philippines one of the top destinations of call center outsourcing. In the last couple of years, these advantages opened doors to other industries, such as application development and maintenance, quality assurance, back-office operations, and digital entertainment.

In a recent survey conducted among CIOs and CEOs, the cultural aspects that they take into consideration include communication style, approaches to completing tasks, attitudes towards conflicts, and differences in decision-making styles. In this regard, allow me to give my two cents’ on the matter and describe briefly how Filipinos do in these areas.

Work around the Filipino communication style

Filipinos are taught the English language as early as pre-school, that by the time they graduate college, their skill in the language are among the most competitive in the world. However, take note of Filipinos indirectness, which is also typical among Asian cultures. Foreign CEOs and expatriates who have been in staying in the Philippines note that “Yes” could mean “yes, but…” or “yes, however…” or “maybe.” The best way to identify whether “yes” is actually “yes” is to listen to the intonation. It would help as well to clarify, ask, or entertain questions from Filipino outsourced workers to make sure that “yes” is not merely “okay.”

Emphasize management and leadership roles

The Philippines ranks relatively high on the power-distance index, which explains the emphasis that workers put on hierarchies. Most decisions are deferred to team leaders and managers, and most importantly, to clients. One implication of this working style is the tendency to strictly follow processes or established methodologies and communication line. To make the most out of this cultural quirk, clients should recognize the role that leaders and managers play in working with them and rallying subordinates. Cultures where results are more important than the processes taken to arrive at them will initially find it uncomfortable. However, most successful outsourcing projects are those that have allowed for results, open communication, and escalation of issues at the initial stages of the project.

Take advantage of service orientation and hour delays

Filipinos are service-oriented, therefore there is the emphasis to please clients or customers. Clients can take advantage of this trait by providing feedback as much as they can to their staff and spell out their expectations at pivotal stages of the project. It also pays to emphasize timeliness because of the tendency of Filipinos to hand in their work almost always two hours late. But for clients who are situated 8 to 16 hours later than the Philippines, most fast-track work are handed in while they are still asleep or getting out of bed.

Last November 20-22, Pacific Asia Conference on Language, Information and Computation (PACLIC) held its 22nd conference on Cebu City, Philippines. PACLIC is an international conference in the area of Machine Learning and AI and has been ranked 49th out of 650 (or among the top 7.5%) Computer Science conferences of the same area. Before the conference, research papers were submitted to PACLIC for evaluation. The author/s of the submitted research papers who passed the double-blind review become/s the speaker/s in the conference.

Software as a Service or Saas has been one of the most popular buzzwords in the tech world these year. Thanks to the popularity of several of its pioneers, the quick deployment, and the relative flexibility in pricing schemes, SaaS is being adopted by businesses of varying sizes, but mostly those of small and medium scale operations.

As the cost of hosting hardware and connectivity goes down and web-based services such as Google Docs, Zoho, or Picnick became more available, the idea of using the Web as an alternative to desktop productivity became more popular. These developments in the past couple of years have made doing everything online and storing nearly everything online made web-based services more popular, such that when SaaS first came into view, it became relatively easy to sell it both as an idea and as a practice that is necessity to business operations.

Still, much of businesses that have sizable IT departments prefer to do it “old skul” and create things in-house and going so far as hiring consultants to develop applications both on-shore and offshore. What gives?

Why develop applications in-house?

• Businesses with large IT workforces and a number of consultants find more value in building products or services for their own internal use instead of “renting” licensed applications. Building their own applications allows them to customize the features and functionalities with each build according to their unique requirements. Moreover, they have more control over the quality of the applications prior to deployment to the enterprise at large.

• No to “cookie cutter” agreements. SaaS agreements are hardly tailor-suited to meet unique business requirements of most clients. The service that one client sights up with is the same service that is being used by other clients.

• Large enterprises prefer to keep customer and business information away from third–or fourth–parties. SaaS providers share applications and space with other businesses, usually competitors. While there may be more positives than negatives in this practice, the idea of sharing the same space with a business competitor does not sit well with businesses, especially those that deal with sensitive data.

• Many large enterprises have to meet government regulations. The financial sector, for example, must meet regulations that govern how the industry should manage information about its assets and clients. Moreover, even without such regulations, financial industry players are not open to handing over their religiously protected data to third-parties, which is what SaaS providers are.

Why SaaS?

• It’s plug-and-play…almost. Ultimately, what you need is a computer and an internet access. The ease of implementation or deployment of SaaS enables a business to focus immediately on its core business instead of build an application (or its subsequent IT team) from the ground up, or purchase an application and negotiate with a service provider to host it.

• Flexible pricing models. This is ideal for businesses that do not have as much cash as big businesses. Most SaaS providers allow negotiated pricing in order to sign up a prospective client for the long term. Subsequently,

• No need to hire new IT staff. For companies or departments that do not have a lot of cash, there is no need to build large teams to produce and maintain applications. Instead, most SaaS companies have the teams to maintain the services themselves, which makes sense, because they own and know their own service and applications better.

MoveAssist, one of Ideyatech’s long-term client, had won the award for Technological Innovation in Relocation. MoveAssist is one of the leading developers of software for movers and relocation managers. The award that has been granted to Robby Wogan, CEO of MoveAssist, is the very first of its kind in the United Kingdom. The award gives due recognition to the quality of the product, to the developers and our people who had worked very hard in developing and maintaining it. Ideyatech is the software development outsourcing partner of MoveAssist and has been doing enhancements and support to this award winning product called Reloassist.

Reloassist won the award because of its usefulness to many relocation companies. It has been useful because it integrates parties so that they can communicate through a web-based platform. It can handle a variety of services and provides flexibility to the different needs of relocation companies. Users of this software can easily configure the software to meet their specific requirements. One client said that ReloAssist has helped them achieve better productivity in their team’s day to day tasks. Thus, they were able to grow without actually having to increase their staff. In addition, the company has also efficiently improved their sales through the use of Reloassist.

Reloassist is a Java-based relocation management system designed to facilitate daily operations of relocating organizations, from corporate HR teams to relocation companies. The application is designed with flexibility in mind and developed on top of a highly robust Java framework using Struts, Spring and Hibernate.

This is another success story Ideyatech.

For more details:

http://www.relocatemagazine.com/awards-dinner.php

http://www.reloassist.com/

Last October, 21, 2008, ideyatech celebrated its Anniversary at the Texas Roadhouse Grill at El Pueblo Real de Manila, Pasig City. The celebration was done in conjunction with the company’s 2008 4^th Quarter General Assembly.

We started with announcements concerning the employees, such as birthday celebrants, promotions, newly-hired employees, trainees, on-the-job trainees (OJTs) and the formalization of our support team. Ideyatech has noticeably grown in size, we are now 17 staff strong from 7 last year. Included are the second batch of J2EE trainees. Ideyatech’s J2EE Training Program commenced last October 16, 2008 and will run through 15 weeks.

Here are some of the highlights of Ideyatech’s success for the past 12 months:

• Established solid team of Java developers and a proven track record.
• Moved to a bigger and better office space (200 sqm).
• Maintained stable list of offshore clients from US, UK and Australia.
• More importantly, positive revenue returns.

The other part of the assembly centered on the different projects that we are handling. Reports were given by the project teams to inform everyone about the project and provide an update on its status and progress.

A short dialogue was provided by Allan regarding the “ecosystem” of Ideyatech, detailing how each entity involved—the developers, the company and the clients—affect each other. A very sensible concept how our business works and how we can help. The whole event was capped off by a discussion of the company’s goals for 2009.

If you want to know more about Ideyatech, you can find more information on our company page.

Are you familiar with common mistakes such as checking equality of two Strings on Java using “==”? Or calling an instance method of a null object? They may look like obvious cases of bugs but many developers are unaware or unconsciously make these kind of codes.

Static code analysis tools, such as FindBugs inspects and analyzes Java bytecode and highlights possible coding errors, bad practice, correctness, malicious code vulnerability, multithreaded correctness, performance, security and dodgy codes without actually running the program.

FindBugs can be downloaded for free. To use FindBugs using the Swing interface, you can execute/run findbugs.sh (on Unix) or findbugs.bat (on Windows) from the bin folder.
1. When the application starts, click File – New Project.
2. On “Class archives and directories to analyze” click Add button, then choose the root folder that contains the compiled classes of your program.
3. On “Source directories”, click the Add button then choose the root folder of the source of your program.
4. Click Finish. FindBugs will scan and analyze all the classes of the program you specified.

After analyzing, FindBugs will show all the potential bugs detected grouped into different categories. When you select a particular bug, it will display the detailed description of the potential bug.

Here’s some statistical analysis as to popularity of recent web technologies in Java. By comparing the searches performed between Struts 2, JSF, Spring MVC and JBoss Seam using Google Trends, it appears that Struts 2 is gaining traction among Java developers while JSF started to lose ground since mid-2007. Searches for Spring MVC and JBoss Seam are increasing but at a slow pace.

On the other hand, jQuery is becoming popular amount Ajax Frameworks. YUI, Dojo and Prototype are roughly equal and jQuery has dramatically surpassed all other frameworks since early this year.

If you’re interested how the graph were generated, try the links below:

Struts 2 vs. JSF vs. JBoss Seam vs. Spring MVC

YUI vs. Prototype vs. JQuery vs. Dojo

Here’s an updated graph on Java technologies as commented below.

The past 12 months has been exciting for Ideyatech. We’ve faced new challenges and have experienced sustainable growth. From a 3 person team, we now have 20 full time developers. We’ve also outgrown our old office and moved to a bigger 200 sqm space. More importantly, our project list and pipeline has been consistently full and we’ve managed to keep everyone busy.

Keeping a Healthy Ecosystem

Our business is an ecosystem where the employees do client work, client pays for the work, and the management keeps the employees and clients. By understanding this ecosystem, it is easy to understand how to keep it healthy. The first act of kindness is for management to keep the employees happy, if employees are happy, they deliver quality work and make client happy. If client is happy, they pay well and makes management happy. If management is happy, they continue to keep the employees happy. This makes up the healthy ecosystem.

At Ideyatech, we value the time of every individual - we allow work-from-home, offsetting, and even pay for overtime. This allows everyone to manage their own time and in doing so, everyone respects time by ensuring every hour spent is productive.

By applying agile methodologies and release schedule, we are able to keep up and manage client expectations. The agile methodology is known to be effective in early software releases without sacrifice to quality. In short, we have established an agile process that works and our clients are happy with it.

Aside from our regular team-building activities such as bowling nights, wii nights, etc. , we also believe and promote “passion at work”… we believe that everyone must come to office with excitement to face daily challenges. We don’t want employees to get “sick and tired” of their 8 hour work. Life is too short to go to waste.

Employee empowerment is also something we practice at Ideyatech. I’ve been constantly giving everyone the opportunity to decide on matters at hand and delegating more responsibilities to them. By doing so, everyone gets to learn new things and become more responsible.

All these efforts and investments are directed towards one single goal, and that is to keep employees happy and that takes care of the entire ecosystem.

If you want to know more about Ideyatech, you can find more information on our company page.

Business Week recently unveiled sponsored benchmark of 2008 IT competitiveness Index, where the Philippines ranked higher than most of its counterparts such India, China, Vietnam, Indonesia and Russia. Suffice to say, Philippines has emerged as one of the major players in the global outsourcing industry specifically on the strength of the following indicators:

• Overall business environment: 0.10
• IT infrastructure: 0.20
• Human capital: 0.20
• Legal environment: 0.10
• R&D environment: 0.25
• Support for IT industry development: 0.15

With a score of 29.8, which is way below the score of this year’s still most competitive country, the United States with 74.6, the Philippines has so much catching up to do. However, no matter the ranking, the country is taking the proverbial baby steps towards the right direction, as the information technology—particularly in software development—and communication are some of the key areas where Philippines can compete with other global players.

Let’s see how the country fares in some of the criteria used by the magazine’s Economist Intelligence Unit.

Overall Business Environment

The country posted a very positive 7.5% GDP growth in 2007, and if not for the recent challenges in the global financial market, the country could have posted at least 5.5% growth in the economy; the Philippine economy has been growing by a positive 5% since 2001. From a low of $1,400 purchasing power parity at the start of the decade, the Philippines enjoys some $3,400 PPP as of 2007.

IT Infrastructure

Thanks to increasing demand from businesses and consumers, local telcos have aggressively pursued broadband development in the past two years. Some $800 million have been spent so far by the country’s leading telcos on improving the infrastructure, which also rides on the popularity of mobile communication in the country. Mobile use enjoys an overall subscriber base of 67% of the population.

Human Capital

The US-based consulting firm, Meta Group ranks the Philippines as the top player in knowledge-based jobs and workers worldwide. The country boasts of a huge army of software engineers, content developers, creative designers, and professionals in accounting and finance, legal, and health care. The Philippines’ emphasis on English as the official mode of instruction is finally paying off, as the Philippines has the third largest English-speaking population.

Support for IT Developments

The government is one of the biggest supporters of the IT industry, thanks to the possibilities that it can provide in creating jobs and making the country globally competitive in business process outsourcing. Last year, the government unveiled regional ITC centers outside Metro Manila, allowing further access to a vast talent pool and tax breaks for businesses that set up offices in assigned economic zones.

The Philippines shows so much promise in offshoring that even India-headquartered outsourcing companies, such as Tata Consulting and Infosys have opened offices in Manila. The local association of outsourcing businesses aims to increase its workforce size to one million and earn revenues of up to US$13 billion by 2010.

If you want to know more about Ideyatech, you can find more information on our company page.

Every month (or so) we conduct a bonding activity to promote employee camaraderie here in Ideyatech. For the month of September we have the mooncake activity (or is this festivity?), where there are prizes (cash), food and of course lots of fun .

Here are some of the pictures (guys, next time remember to smile to the shutter):

Just in case you don’t know what Mooncake is all about (sounds like me) here’s an email from Philip (our events organizer)

“ Buddhists, Taoists and believers of Chinese folk religions consider the seventh lunar month (August) as the “Ghost Month,” otherwise known as the “Month of the Hungry Ghosts”, in which ghosts and spirits, including those of the deceased ancestors, come out from the lower realm. The first day of the month is called the “Opening of the Gates of Hades” since it is believed that the gates of Hell are flung open on this day to allow the ghosts and spirits of the nether world into the world of the living for a month of bacchanal of food and wine. This earthly party comes to an end on the last day of the month, called the “Closing of the Gates of Hades,” since the portals to the spirit world are shut once again on this day. On the 15th day of Ghost Month, many people stay at home to avoid an unlucky encounter with a ghost out enjoying the Ghost Festival; and special care is taken to avoid walking near riverbanks where a water spirit may easily steal the body of the living. During this whole period, the believers suspend all important activities and decisions. “

This is my first mooncake experience and by the end of the game I got a total of 420, not bad at all.

Full picture set is located here.

Virtualization, traces of Web 2.0, and efficiency are the key trends that will rule the tech world starting next year, according to Gartner, Inc.

The research company predicts that the 10 hottest technologies will have long-term impact on business and the IT industry itself, thanks to “high potential for disruption to IT or the business,” the amount of investment, the risks of late adoption, and the rewards of early implementation.

Topping the list is virtualization, particularly server virtualization, which has the potential to lower the cost of storage and media devices. According to David Cearley, vice president at Gartner, today’s virtual hosting technologies encourage the reduction of data duplication, and combined with the impression that the quality of hosted data are as good as those stored in personal computers or company servers, the trend will eventually result in lower costs of data storage devices and equipment.

With the attention accorded to Software as a Service (SaaS), its next of kin, cloud computing, comes in second. Cost, scalability, and “elasticity” are the primary reasons for the increase in adoption of the technology next year. Most of its adopters will be composed of small and medium size enterprises, but large organizations are not far behind in embracing the technology.

The third trend focuses on the development of servers that allows for provisioning of resources according to end-users’ needs. New server technologies will enable companies to combine available resources instead of purchase separate systems for hardware and software requirements. This reduces inventory and eliminates wasted assets. While server blades have nearly the same approach, these are still not as flexible.

The fourth trend centers on Web-inspired architectures, specifically, the technologies, standards and design approaches that promote “agile, interoperable and scalable service-oriented environment.” Gartner predicts that the Web-oriented approach to technology innovation will be integrated into more enterprise solutions in the next five years.

Enterprise mashups, the fifth trend to capture the technology world starting in 2009, has its roots in the Web industry. As mashups became one of the standards of Web 2.0, Gartner expects that enterprises will explore the approach’s potential in business computing environments.

The other five that round up the list are specialized systems that address the demands of “general-purpose computing markets,” social software and social networking, unified communications or consolidation of communications technologies, business intelligence technologies that assist organizations in “making smarter decisions at every level of the business,” and green IT and its resulting energy efficient products.

Gartner’s forecast does not mention outsourcing, but it is easy to predict that with the increasing need for  technology upgrade and maintenance, combined with cost-cutting demands brought on by the current economic challenges, companies will continue to ship part of their technology work offshore. What the forecast provides, on the other hand, is a peek at the next wave of tech trends that will be adopted by various industries.

When it comes to the outsourcing industry in the Philippines, the first thing—if not the only—that comes to mind is the contact center sector. With nearly half a million Filipinos employed, the call center industry is so far the brightest sector in the Philippine economy.

Beyond contact centers, the Philippines is also making waves in IT, particularly software development. In recent years, the tech sector has also embraced a more robust IT consulting, which includes implementation, deployment, and administration of IT systems.

Analysts project that the total size of the Philippines’ ICT sector will increase from US$1.2 billion in 2005 to US$2.3 billion by the end of the decade. The Philippine government recently unveiled a five-year program, which it hopes to generate up to US$12.8 billion, from the combined contact center and IT services sectors. Out of the projected worth, it is not known how much software development will contribute. But with satellite development centers for leading technology firms opening on these shores, it is safe to say that the application development outsourcing industry is on a growth path.

Taking advantage of the large number of college-educated workforce, engineers, and application developers all over the country, the government has opened regional centers to provide low-cost labor to firms based in Europe, North America and Australasia. The tech sector eyes the financial services industry; locally, SMEs will spur the growth in IT.

There are a number of challenges, though, that the tech sector faces. For one, the local market is not yet ready to sustain growth in the IT industry due to lack of funds and business models that do not fully integrate automation, analysts say. Moreover, competition from the rest of the region poses a challenge to projected growth. The Philippines is fourth, behind India, China and Malaysia, in attracting offshore outsourcing deals. Political upheavals and lack in infrastructure development hinder further growth.

Junior and middle management still need to keep up with emerging practices in process methodologies and management practices. According to a McKinsey Group report, The Philippines’ Offshoring Opportunity (2005):

“… for all its potential, the Philippines faces enormous challenges in achieving this goal. MGI research shows that, although it boasts widespread English language skills, very low costs, and promising human resource capabilities, it lags behind India and many other potential offshoring locations on several of the key criteria companies examine when choosing an offshoring location. These include risk, infrastructure, the availability of vendors, and the supply of middle managers who are key to establishing large offshore operations quickly.

If the Philippines is to capitalize on the opportunities that are undoubtedly there for the taking, the government, together with the private sector, must work to strengthen the perceived attractiveness and reality of offshoring to the Philippines.”

After two days of debugging our codes on transaction handling, I’m writing this post to share my experience so others don’t have to undergo the same pain and torture. However, this post assumes that you’ve setup your Spring transactions - either via AOP or annotations. If you haven’t done so, here are some good references:

1. Spring Framework - Transaction Management
2. On Java - Wire Hibernate Transactions in Spring

So, once you’ve setup or tried to setup transactions and failed - here are some tips how to debug your transaction management.

Enable logging. In log4j.properties, add log4j.logger.org.springframework.orm.jpa=DEBUG to enable logging of JPA transactions. This will allow you to trace the activities behind the Spring transaction processes. The logs provide detailed information about new, reused and active transactions, transaction modes, transaction commits and more. This is the best way to understand how transaction behaves on your application and gives you an insight how to fix your transactional problems.

Check your database and dialect. Dialects affect transaction handling so be sure to use the appropriate dialect for your database. Note that there are 2 dialects to define - JPA Dialect and Hibernate Dialect. JPA dialect is defined in the EntityManagerFactory while Hibernate is defined in Hibernate properties.

JPADialect is defined in EntityManagerFactory as shown below:


<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource"><ref bean="dataSource"/></property>
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
</property>
<property name="persistenceUnitName">
<value>hibernateConfig</value>
</property>
</bean>

While Hibernate Dialect is defined via persistence.xml.

Watch out for listeners, they could mess up your transactions. A couple of examples about listeners (especially ApplicationListener) found online doesn’t consider transaction handling. Most of them performs data updates within the listener. This should not be the case because in doing so, you could be creating a transaction on the listener which forces all other operations to reuse that transaction. The better way of doing it is to call a service or business layer to perform transactional operations. This way, transaction is created only when the service is invoked.

Declare your transaction as readOnly whenever possible. Read-only transactions run faster so enable this on non-writing functions - (e.g. load, read, find, etc). Also, this avoid transaction commits on binded-data. One specific scenario is when Spring validation throws an error and data is still saved despite the validation error, this means that the data was loaded on a non-readOnly transaction and Spring transaction is committing it.

Reduce your transactional method calls. Put all your business logic function calls in one method marked with @Transactional and avoid calling other methods with their own transaction declarations. For example, if your transactions are declared on service layer, avoid calling another service method because this will trigger transactional checks which unnecessarily slows down the system. Call the DAO method directly instead. This way all your operation are contained in a single transaction declaration.

Understand propagation. Transaction propagation is hard to understand because the effects cannot be easily seen in your application… until you start performance tuning or having problems on saved data. Take note that if your transaction propagation is default, it will try to reuse existing transactions. This means that you could lose your transaction settings (e.g. readOnly), because new transaction was not created instead an existing was reused.

We envision Ideyatech to be an agile, creative and pro-active software development company. We never intend to become like any other outsourcing company that provides cookie cutters. As part of this effort, we redefined the developer titles and roles.

We classified our developers into three: Codester, Codesmith and Codemaster. However, it’s more than just the making new titles… we also redefined their roles.

Codester
A codester is a dynamic individual who has passion for abstract and logical reasoning. He is trained in the art of programming and is experienced in the Java language. He is resourceful and capable of learning new technologies on his own. Codester are people you can rely on to deliver codes that work according to specifications.

Codesmith
A codesmith crafts their codes with artistic mastery. He is capable of writing clean, well-designed codes. He is well-versed in the art of programming and ensures that his codes are optimized, refactored and properly unit-tested. Codesmiths are your best bet in doing complex and more advanced transactional web applications.

Codemaster
A codemaster is one of the chosen few who can design unique solutions to common complex problems. Unlike traditional developers, he thinks of solutions with a business sense. In addition, he is an expert in design patterns - not only in theory, but also in practice. Codemasters are the perfect partners for product development since they have the creative insight and technical proficiency in developing state-of-the-art applications.

Offshore outsourcing is a brilliant business strategy for many businesses. Gartner analysts predict that offshore outsourcing will rise by 8.9% in 2008, and the trend will continue on to 2009. However, it is not (yet) a perfect solution to various business issues and requirements. Before engaging the services of vendors, whether by offshore or onshore outsourcing, it is important to know that outsourcing has its own sets of issues.

The bright side of the debate is that if a business understands the issues surrounding outsourcing, these “cons” can easily be turned into “pros” that will add up to profitability and result in better quality of products and services. Below are some of the risks that you must understand about outsourcing:

• You are putting parts of your business in someone else’s hands. Realize that you are inviting a third party into your own operations. Business matters that used to be kept within your company’s walls are being laid open to the scrutiny of the vendor, or as some say, consultant. While trust must be established between the company and the vendor, it is absolutely necessary to form security measures from contracts to security audits. And be hard-headed in the implementation of these contracts. In most security breaches, the weakest points are not the systems put in place to prevent data leaks, but humans, the staff themselves, who fail to understand the enormity of keeping corporate information secure.

• Business experts and visionaries are still a weak spot among outsourcing destination. Offshore outsourcing vendors can provide highly skilled workers who can perform volume tasks. However, management is often a weak spot among vendors. This means the lack of familiarity or knowledge of established processes by your company, lack of enough knowledge about your business or industry. In cases like these, it is important to know the people who will lead your outsourcing team. In many situations, middle- and junior managers receive months-long trainings on-shore before getting their feet wet with actual project delivery.

• Unfavorable business conditions in offshore destinations include economic and political factors. If you think that you are giving away control of parts of your businesses to companies located outside your country, consider how much less control you will have if you factor in the political and economic upheavals in that country.  Any upheavals at all poses risks of operational disruptions. You must make sure that there are business continuity measures put in place in case it is business unusual offshore.

• Businesses only consider outsourcing in terms of cost-savings instead of value to the company. This weakness happens on both ends of the outsourcing spectrum. Both business and vendor only see outsourcing as a way to cut costs instead of adding value to the company’s product, services, customer relationship, among other things. Instead of concentrating on the outsourcing relationship in terms of money savings alone, it is important to add long-term product or service innovation and process improvement in the mix. The money saved today can be reinvested into bigger endeavors tomorrow.

Outsourcing, especially offshore outsourcing, has been constantly cast in a bad light for its perceived ill effects on the job security of thousands of workers from developed economies. However, it is interesting to ask this question: If outsourcing’s negative effects far outweigh its positive results, then why does it still flourish? Is it all about the money? Apparently, the answer is “No”.

This is not to say that outsourcing does not have its bad side. In this two-part blog post, let us explore where outsourcing works, and where it should improve.

• Outsourcing allows small and medium size businesses to have more workers. Small and medium-size enterprises do not have the luxury of permanently employing large armies of workers to work on projects, such as software development, QA, accounting systems, documentation, or customer management. However, outsourcing allows them to engage as many workers as their projects need—or as they can afford—temporarily. At the end of a project’s lifecycle, a lot of companies find it easier to halt relationships with vendors than with employees.

• Outsourcing allows companies to focus on their core competencies. This is one of the most popular and oft-repeated responses to outsourcing critics, and it is worth mentioning many times over. By outsourcing processes that require low or mid-level skills, companies can focus on parts of their operations that need high levels of skills gathered from extensive industry experiences. Basic Java development can be handled by offshore workers, while software architecture and design are best handled by onshore resources.

• Outsourcing offers staffing flexibility. With hundreds of thousands of available workers in application development, customer management, and support services available in low-income service providers, companies have the flexibility to hire on project basis. At the end their projects, it is easier to decide whether to retain talents or hire new ones, even new vendors.

• Outsourcing saves money. Offshore workers in an emerging economy, such as the Philippines, can provide the same quality of work at a much lower cost. Outsource workers in emerging markets are college graduates and most have job experiences relevant to outsourcing requirements. For example, IT workers in Manila are college degree holders who have also received formal trainings in specific programming languages. On top of that, IT vendors also arm their workers with trainings in consulting, customer management, communication, and methodologies. Over time, the smaller amount paid to low-wage outsource workers increase in value.

For the past two months, we have been having our weekly T3 (Tuesday Tech Talk) sessions. It’s a 30-minute discussion about any technical topic the presenter would like to discuss. Presenters are randomly selected from the development group.

So far, we have received nothing but benefits from this activity. Here are some of its benefits and advantages:

1. The presenters get an opportunity to talk, express themselves and practice their presentation skills. More importantly, they steer away from the developer mindset for a while, get out of their shells, and think of good topics to discuss.
2. The attendees learn something new. Everybody seems to know something others don’t.
3. Everyone begins to understand the specialization and span of knowledge of their colleagues. In this way, it becomes easier to know who to ask regarding particular topics. Subsequently, the developers become experts and specialists in their own way.
4. This builds camaraderie within the team. Everyone relaxes and opens up their minds for new knowledge.
5. The topics discussed are usually not something we do or use in our daily routine at work. So, everyone gets to learn more than the usual stuff.
6. Everyone realizes the things that they do not know and starts to seek for more information about it.
7. The organization strengthens its corporate IQ as people share their ideas and knowledge with each other.
8. After a couple of sessions, everyone began appreciating the activity and now looks forward for new things to learn.

If you want to know more about Ideyatech, you can find more information on our company page.

Outsourcing helps your business by allowing it to focus its energies and resources on its core strengths. However, the success of outsourcing depends on a lot of factors, the top of which comes from you, the party that decides on whether outsourcing will actually help you achieve your business goals.

What are the success factors involved in outsourcing? The list can be very long, as it all depends on a company’s goals, size, budget, and the risks it is willing to take. The following are some common ways to make an outsourcing project successful:

• Identify your business goals. Know why you are outsourcing in the first place. Is it to cut costs? Is it to have more flexibility in growing your manpower? Is it to provide better customer service? The most common reason behind outsourcing is to cut costs. However, this poses a risk in the long run. There are savings that can be made by shipping some business processes to low-wage economies, but make sure that you also get more value for how little you are willing to spend in terms of process improvement, quality, and customer satisfaction.
• Choose your vendor carefully. Before signing an agreement with a vendor, make sure that you have made ample background checks for its financial stability, management team, flexibility, workforce, and best of all, the methodologies that it implements in the course of your project cycle. Search for reference that will vouch for the capabilities of the vendor. This is the third party that will handle part of your business. No matter the size, each part of your overall operations plays a crucial role in your business success. Choose your vendor well.
• Engage everyone’s support. Everyone from all levels of the organization should support the involvement of outsourced personnel–or consultants–in the project. Top executives should buy in to the project because they are ultimately responsible for the venture. Regular employees should show not see outsourcing as a threat to their employment.
• Agree on project management methodologies, and training and communication plans. Depending on the complexity of the project, there is a high learning curve involved at the start of the project. Make sure that prior to the start of the project’s outsourcing, all blueprints are laid out. Communication and training plans, implementations methods, channels and facilities are crucial in the knowledge transfer. And most of all, the project methodologies should be agreed upon in order to keep risks at minimum levels.

When it comes to outsourcing opportunities in the Philippines, one most often calls to mind call centers or customer service. Being an English-speaking country (Philippines is the third largest English-speaking country in the world), it has an edge over call center outsourcing destinations, such as India or even China. The Philippines also boasts of college educated customer service agents who are adept at handling customer complaints and requests.

Next to call center or customer service support, Philippines has also made a considerable progress in the medical transcription business. On top of the labor force’s ability to speak and write in English, it has a surplus of workers with degrees in the medical field, such as nursing, pharmacy, and medical technology, thanks to the growing trend of exporting medical workers to developed countries, such as the US, UK, and the Middle East.

Software Development Outsourcing to the Philippines

Is Philippines in a good position to take a cut in the technology outsourcing pie? Fortunately, the answer is yes, according to analysts.

While still trailing behind India and China, the country “is already emerging as a strong player in this rapidly evolving industry, demonstrating that it can compete with India and other low-wage destinations in creating value,” according to a 2005 report by the McKinsey Global Institute (MGI). Case in point: While Philippines’ population is 16 times smaller than China, it produces twice as many engineers, according to MGI.

In 2007, the Philippines captured USD 4.1 billion or 1.4% of the global outsourcing market share. According to a Reuters report, diversifying outsourced opportunities beyond call centers will earn the country up to $12.2 billion by 2010.

Opportunities Despite Tech Spending Crunch

Because of the global economic crunch, cuts in IT spending are inevitable. The upside of belt-tightening measures is off-shoring of technology jobs. Of course, the downside could be that the growth of off-shored tech opportunities may not be as high as it was projected in the past years. Still, opportunities abound for outsourcing destinations, such as the Philippines.

Filipino engineers and generalist tech workers have become attractive to foreign companies. “Poaching” of tech workers by other Southeast Asian countries has been observed over the past 3 years, thanks to their technical and communication skills. This temporary diaspora of Filipino tech workers offers better earning opportunities to the workers themselves, but on a larger and more important scale, world-class training experiences that they can bring back home.

If the tech industry can supply ample technical and managerial training to its workers, the Philippines can become a more attractive outsourcing destination for technical development. The country should not rest on its call center laurels alone.

A common requirement in developing enterprise applications is to ensure audit logs are available for data security and traceability–who made the changes, when they were made, and what files or sections were changed. This requirement is not only dictated by corporate IT policies, but also required by government laws. Considering that most enterprise applications have at least 50 domain objects, implementing audit logs on each of them can be time-consuming. So, a generic solution must be established to minimize coding when creating audit logs.

The Solution

• Use Hibernate interceptors to trigger change events.
• Use Java reflections to retrieve old and new data.
• Create an interface to switch logging on or off for every data object.

1. Create an Auditable interface as a marker on the data that needs to be audited. Any data object that needs to be audited must implement this Auditable interface.
2. Create an AuditLog to store log information. This contains the date (when), user (who), class name, object id and the audit message (what).
3. Create an AuditLogInterceptor that will keep track of all data change events and store all the  changes performed.
4. Create a utility that can retrieve object values using Java reflections to process generic data retrieval.
5. Create sample usage of auditing.

public interface Auditable {
	/**
	 * Retrieve the primary key
	 * @return
	 */
	public Long getId();

	/**
	 * Returns the list of fields that should be audited.
	 * @return
	 */
	public List getAuditableFields();

	/**
	 * Returns the field of the primary identifier (e.g. title).
	 * This field is used to uniquely identify the record.
	 * @return
	 */
	public String getPrimaryField();

	/**
	 * Returns customized audit log message. When empty, audit logging
	 * uses standard audit message.
	 * @return
	 */
	public String getAuditMessage();
}

The AuditLog entity must be able to store who, when, what:

package com.ideyatech.core.bean;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EntityListeners;
import javax.persistence.Lob;
import javax.persistence.Table;
import javax.persistence.Transient;

import com.ideyatech.core.bean.user.BaseUser;
import com.ideyatech.core.persistence.listener.AuditLogListener;
import com.ideyatech.core.util.CrudUtil;

/**
 * This class is responsible for handling all audit functions
 * needed to be attached to the classes.
 *
 * @author allantan
 */
@Entity
@Table(name=”HISTORY_LOG”)
public class AuditLog implements Serializable {
	private static final long serialVersionUID = 269168041517643087L;
	@Column(name = “ENTITY_ID”,nullable=false,updatable=false)
	private Long entityId;
	@SuppressWarnings(”unchecked”)
	@Column(name = “ENTITY_CLASS”,nullable=false,updatable=false)
	private Class entityClass;
	@Column(name = “REFERENCE”)
	private String reference;
        @Column(name = “CREATE_DATE”)
        @Temporal(TemporalType.TIMESTAMP)
        private Date createDate;
	@Lob
	@Column(name = “MESSAGE”,nullable=false,updatable=false)
	private String message;
	@Column(name = “USER_ID”,nullable=false,updatable=false)
	private Long userId;
	@Transient
	private transient Object object;
	@Transient
	private transient BaseUser user;

	public AuditLog() {
	};
	@SuppressWarnings(”unchecked”)
	public AuditLog(String message, Long entityId, Class entityClass, Long userId) {
		this.message = message;
		this.entityId = entityId;
		this.entityClass = entityClass;
		this.userId = userId;
		this.setCreateDate(new Date());
	}

	/**
	 * @return the entityId
	 */
	public Long getEntityId() {
		return entityId;
	}

	/**
	 * @param entityId the entityId to set
	 */
	public final void setEntityId(Long entityId) {
		this.entityId = entityId;
	}

	/**
	 * @return the entityClass
	 */
	@SuppressWarnings(”unchecked”)
	public Class getEntityClass() {
		return entityClass;
	}

	/**
	 * @param entityClass the entityClass to set
	 */
	public final void setEntityClass(Class entityClass) {
		this.entityClass = entityClass;
	}

	/**
	 * @return the message
	 */
	public String getMessage() {
		return message;
	}

	/**
	 * @return the userId
	 */
	public Long getUserId() {
		return userId;
	}

	/**
	 * @param userId the userId to set
	 */
	public void setUserId(Long userId) {
		this.userId = userId;
	}

	/**
	 * @return the object
	 */
	public Object getObject() {
		return object;
	}

	/**
	 * @param object the object to set
	 */
	public void setObject(Object object) {
		this.object = object;
	}

	/**
	 * @return the user
	 */
	public BaseUser getUser() {
		return user;
	}

	/**
	 * @param user the user to set
	 */
	public void setUser(BaseUser user) {
		this.user = user;
	}
}

The AuditLogInterceptor is responsible in tracking the changes and creating necessary Audit logs. Notice that session is created from a separate HibernateUtils session so that the original(unchanged) data can be retrieved for comparison.

package com.ideyatech.core.persistence.interceptor;

import java.io.Serializable;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.log4j.Logger;
import org.hibernate.CallbackException;
import org.hibernate.EmptyInterceptor;
import org.hibernate.Session;
import org.hibernate.type.Type;

import com.ideyatech.core.bean.Auditable;
import com.ideyatech.core.persistence.impl.AuditLogDAOImpl;
import com.ideyatech.core.util.CrudUtil;
import com.ideyatech.core.util.HibernateUtil;
import com.ideyatech.core.util.StringUtil;

/**
 * This is the interceptor responsible in tracking audit trails.
 * Source is patterned after the book “Java Persistence with Hibernate” - page 546 onwards
 * and merged with http://www.hibernate.org/318.html
 *
 * @author allantan
 */
public class AuditLogInterceptor extends EmptyInterceptor {
	private static final long serialVersionUID = 582549003254963262L;

	private static Logger _log = Logger.getLogger(AuditLogInterceptor.class);

    private Set inserts    = new HashSet();
    private Set updates    = new HashSet();
    private Set deletes    = new HashSet();
    private Map oldies     = new HashMap(); 

    @Override
    public boolean onSave(Object entity,
                          Serializable id,
                          Object[] state,
                          String[] propertyNames,
                          Type[] types)
            throws CallbackException {
        if (entity instanceof Auditable)
            inserts.add((Auditable)entity);
        return false;
    } 

	/* (non-Javadoc)
	 * @see org.hibernate.EmptyInterceptor#onDelete(java.lang.Object, java.io.Serializable, java.lang.Object[], java.lang.String[], org.hibernate.type.Type[])
	 */
	@Override
	public void onDelete(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {
        if (entity instanceof Auditable)
            deletes.add((Auditable)entity);
	}

    @Override
    public boolean onFlushDirty(Object entity,
                                Serializable id,
                                Object[] currentState,
                                Object[] previousState,
                                String[] propertyNames,
                                Type[] types)
            throws CallbackException {
        if (entity instanceof Auditable) {
        	try {
	        	// Use the id and class to get the pre-update state from the database
	        	Session tempSession =
	                HibernateUtil.getSessionFactory().openSession();
	        	Auditable old = (Auditable) tempSession.get(entity.getClass(), ((Auditable) entity).getId());
	            oldies.put(old.getId(), old);
	        	updates.add((Auditable)entity);
        	} catch (Throwable e) {
        		_log.error(e,e);
        	}
        }
        return false;
    } 

    @Override
    public void postFlush(Iterator iterator)
                    throws CallbackException {
        try {
        	for (Auditable entity:inserts) {
        		if (!entity.skipAudit()) {
        			if (StringUtil.isEmpty(entity.getAuditMessage()))
        				AuditLogDAOImpl.logEvent(
        						CrudUtil.buildCreateMessage(entity), entity);
        			else
        				AuditLogDAOImpl.logEvent(
        						entity.getAuditMessage(), entity);
        		}
        	}
        	for (Auditable entity:deletes) {
        		if (!entity.skipAudit()) {
        			if (StringUtil.isEmpty(entity.getAuditMessage()))
        				AuditLogDAOImpl.logEvent(
        						CrudUtil.buildDeleteMessage(entity), entity);
        			else
        				AuditLogDAOImpl.logEvent(
        						entity.getAuditMessage(), entity);
        		}
        	}
        	for (Auditable entity:updates) {
        		if (!entity.skipAudit()) {
        			if (StringUtil.isEmpty(entity.getAuditMessage())) {
		        		Auditable old = oldies.get(entity.getId());
		        		AuditLogDAOImpl.logEvent(CrudUtil.buildUpdateMessage(old, entity), entity);
        			} else
        				AuditLogDAOImpl.logEvent(
        						entity.getAuditMessage(), entity);
        		}
        	}
        } catch (Throwable e) {
    		_log.error(e,e);
    	} finally {
            inserts.clear();
            updates.clear();
            deletes.clear();
            oldies.clear();
        }
    }
}

This is a continuation of the post “Audit Logging via Hibernate Interceptor“.

Other helper functions are shown below:

CrudUtil is the class responsible for retrieving object values using Java reflections:

import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;

import com.ideyatech.core.InvalidImplementationException;
import com.ideyatech.core.bean.Auditable;
import com.ideyatech.core.bean.BaseCriteria;
import com.ideyatech.core.bean.BaseEntity;

/**
 * @author allanctan
 *
 */
public class CrudUtil {

    private static Logger _log = Logger.getLogger(CrudUtil.class);

	private static final String SQL_PARAM = “:([^\\s]+)”;
	private static final Pattern SQL_PARAM_PATTERN = Pattern.compile(
			SQL_PARAM, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);

    /**
     * Creates the logging message for new audit logs
     * @param obj
     * @return
     */
    public static String buildCreateMessage(Auditable obj) {
    	StringBuffer message = new StringBuffer(”Added “);
    	message.append(obj.getClass().getSimpleName())  // class name
    		.append(” “)
    		.append(obj.getPrimaryField())
    		.append(”:”);
    	Object value = retrieveObjectValue(obj, obj.getPrimaryField());
    	if (value!=null)
    		message.append(value.toString())
    		.append(” - “);
    	// loop through the fields list
		List auditFields = obj.getAuditableFields();
		int count = 0;
		for (String property:auditFields) {
			Object ret = retrieveObjectValue(obj, property);
			if (ret!=null && ret.toString().trim().length()>0) {
				if (count > 0)
					message.append(” and “);
				message.append(property)
					.append(”=”)
					.append(ret.toString());
				count++;
			}
		}

    	return message.toString();
    }

    /**
     * Creates the logging message for update audit logs
     * @param obj
     * @return
     */
    public static String buildUpdateMessage(Auditable oldObject, Auditable newObject) {

    	StringBuffer message = new StringBuffer(”Changed “);
    	message.append(oldObject.getClass().getSimpleName())  // class name
    		.append(” “)
    		.append(oldObject.getPrimaryField())
    		.append(”:”);
    	Object value = retrieveObjectValue(oldObject, oldObject.getPrimaryField());
    	if (value!=null)
    		message.append(value.toString())
    		.append(” - “);
    	// loop through the fields list
		List auditFields = oldObject.getAuditableFields();
		int count = 0;
		for (String property:auditFields) {
			Object oldValue = retrieveObjectValue(oldObject, property);
			Object newValue = retrieveObjectValue(newObject, property);
			if (oldValue == null) oldValue = new String(”");
			if (newValue == null) newValue = new String(”");
			if (!oldValue.equals(newValue)) {
				if (count > 0)
					message.append(” and “);
				message.append(property)
					.append(” from ‘”)
					.append(oldValue.toString())
					.append(”‘ to ‘”)
					.append(newValue.toString())
					.append(”‘”);
				count++;
			}
		}

    	return message.toString();
    }

    /**
     * Creates the logging message for new audit logs
     * @param obj
     * @return
     */
    public static String buildDeleteMessage(Auditable obj) {
    	StringBuffer message = new StringBuffer(”Deleted “);
    	message.append(obj.getClass().getSimpleName())  // class name
    		.append(” “)
    		.append(obj.getPrimaryField())
    		.append(”:”);
    	Object value = retrieveObjectValue(obj, obj.getPrimaryField());
    	if (value!=null)
    		message.append(value.toString());
    	return message.toString();
    }

    /**
     * Retrieves the property name for a method name.
     * (e.g. getName will return name)
     * @param methodName
     * @return
     */
    public static String getPropertyName(String methodName) {
    	if (StringUtil.isEmpty(methodName) || methodName.length()<=3)
    		return null;
    	if (methodName.startsWith(”get”) || methodName.startsWith(”set”)) {
    		String prop = methodName.substring(4);
    		char c = Character.toLowerCase(methodName.charAt(3));
    		return c+prop;
    	} else
    		return null;
    }
    /**
     * Retrieves the getter method name for a given property.
     * (e.g. name will return getName)
     * @param propertyName
     * @return
     */
    public static String getGetterMethodName(String propertyName) {
    	if (StringUtil.isEmpty(propertyName) || propertyName.length()<=0)
    		return null;
    	char c = Character.toUpperCase(propertyName.charAt(0));
    	return “get”+c+propertyName.substring(1);
    }

	/**
	 * This method retrieves the object value that corresponds to the property specified.
	 * This method can recurse inner classes until specified property is reached.
	 *
	 * For example:
	 * obj.firstName
	 * obj.address.Zipcode
	 *
	 * @param obj
	 * @param property
	 * @return
	 */
	public static Object retrieveObjectValue(Object obj, String property) {
		if (property.contains(”.”)) {
			// we need to recurse down to final object
			String props[] = property.split(”\\.”);
			try {
				Method method = obj.getClass().getMethod(getGetterMethodName(props[0]));
				Object ivalue = method.invoke(obj);
				if (ivalue==null)
					return null;
				return retrieveObjectValue(ivalue,property.substring(props[0].length()+1));
			} catch (Exception e) {
				_log.error(”Failed to retrieve value for “+property);
				throw new InvalidImplementationException(”CrudUtil”,”retrieveObjectValue”,null,”", e);
			}
		} else {
			// let’s get the object value directly
			try {
				Method method = obj.getClass().getMethod(getGetterMethodName(property));
				return method.invoke(obj);
			} catch (Exception e) {
				_log.error(”Failed to retrieve value for “+property);
				throw new InvalidImplementationException(”CrudUtil”,”retrieveObjectValue”,null,”", e);
			}
		}
	}

	/**
	 * This method retrieves the object type that corresponds to the property specified.
	 * This method can recurse inner classes until specified property is reached.
	 *
	 * For example:
	 * obj.firstName
	 * obj.address.Zipcode
	 *
	 * @param obj
	 * @param property
	 * @return
	 */
	public static Class retrieveObjectType(Object obj, String property) {
		if (property.contains(”.”)) {
			// we need to recurse down to final object
			String props[] = property.split(”\\.”);
			try {
				Method method = obj.getClass().getMethod(getGetterMethodName(props[0]));
				Object ivalue = method.invoke(obj);
				return retrieveObjectType(ivalue,property.substring(props[0].length()+1));
			} catch (Exception e) {
				_log.error(”Failed to retrieve value for “+property);
				throw new InvalidImplementationException(”CrudUtil”,”retrieveObjectValue”,null,”", e);
			}
		} else {
			// let’s get the object value directly
			try {
				Method method = obj.getClass().getMethod(getGetterMethodName(property));
				return method.getReturnType();
			} catch (Exception e) {
				_log.error(”Failed to retrieve value for “+property);
				throw new InvalidImplementationException(”CrudUtil”,”retrieveObjectValue”,null,”", e);
			}
		}
	}
}

HibernateUtil is a utility to retrieve hibernate session separate from the usual EntityManager.

import java.net.URL;
import java.util.Set;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.scannotation.AnnotationDB;
import org.scannotation.ClasspathUrlFinder;

/**
 * This utility allows creation of Hibernate session directly.
 * Used for logging purposes.
 *
 * @author allantan
 */
public class HibernateUtil {
    private static final SessionFactory sessionFactory;
    static {
        try {
        	URL[] urls = ClasspathUrlFinder.findResourceBases(”META-INF/persistence.xml”);
        	AnnotationDB db = new AnnotationDB();
        	db.scanArchives(urls);
        	Set entityClasses = db.getAnnotationIndex().get(javax.persistence.Entity.class.getName());
            // Create the SessionFactory
        	AnnotationConfiguration ac =  new AnnotationConfiguration();
            ac.setProperty(”hibernate.connection.datasource”, “java:comp/env/jdbc/ideyatech”);
            ac.setProperty(”hibernate.dialect”, “org.hibernate.dialect.MySQLDialect”);
            for (String clazz:entityClasses) {
            	ac.addAnnotatedClass(Class.forName(clazz));
            }
            sessionFactory = ac.buildSessionFactory();
        } catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println(”Initial SessionFactory creation failed.” + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

And finally, the sample implementation of an Auditable class:

public class InboundDocument implements Auditable {
	private static final long serialVersionUID = -7019861759834380358L;

	@Column(name = “DATE_RECEIVED”)
	@Field(index = Index.UN_TOKENIZED, store = Store.YES)
	@DateBridge(resolution = Resolution.DAY)
	private Date dateReceived;

	@Column(name = “NUMBER_OF_DAYS”)
	private Integer numberOfDays;

	@Column(name = “DATE_DUE”)
	@Field(index = Index.UN_TOKENIZED, store = Store.YES)
	@DateBridge(resolution = Resolution.DAY)
	private Date dateDue;

	@ManyToOne(fetch = FetchType.EAGER)
	@JoinColumn(name = “ACTION_NEEDED”)
	@Field(index = Index.TOKENIZED)
	@FieldBridge(impl = SystemCodesBridge.class)
	private SystemCodes actionNeeded;

        …
        …

	public List getAuditableFields() {
		List props = new ArrayList();
		props.add(”documentType”);
		props.add(”actionNeeded”);
		props.add(”dateReceived”);
		props.add(”dateDue”);
		props.add(”summary”);
		return props;
	}

	public String getPrimaryField() {
		return “barcodeNumber”;
	}
}

That’s it! Just implement all your auditable classes with Auditable interface. All the codes above are extracted from open-tides - an open-source web-foundation framework that can be used to quickly setup an enterprise project.