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 signifcant 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.

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.

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 27 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.

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.

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.

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.

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.

My team member has a requirement to implement JMS. I was able to dig up some stuff about JMS in my blog. I’m re-posting it here since it might be useful. For this example, I used IBM Websphere Community Edition(IBM WAS CE), which is synonymous to Geronimo(at least for the first version).

Here are the simple steps:

1. Run Geronimo or IBM WAS CE
2. Compile these two classes. Take note that you need the ff. jar files to compile and run these successfully. Here’s the list:

- geronimo-j2ee_1.4_spec.jar
- commons-logging-1.0.4.jar
- concurrent-1.3.4.jar

Note : Some jars might have new versions so be sure to use the latest one.

You’ll find it somewhere under the Geronimo or WAS CE installation directory.

3. Run the clients.

The receiver class

import java.util.logging.Logger;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.activemq.ActiveMQConnectionFactory;

public class JMSReceiver {
    protected Queue queue;

    protected String queueName = “SendReceiveQueue”;
    protected String url = “tcp://localhost:61616″;

    Logger logger = Logger.getAnonymousLogger();

    protected int ackMode = Session.AUTO_ACKNOWLEDGE;

    public static void main(String[] args) {
        JMSReceiver msgReceiver = new JMSReceiver();
        msgReceiver.run();
    }

    public void run() {
        QueueConnection connection;
        QueueSesion session;
        MessageConsumer consumer;
        try {
            ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
            onnection = (QueueConnection)connectionFactory.createConnection();
            connection.start();
            consumer = null;
            session = connection.createQueueSession(false,Session.AUTO_ACKNOWLEDGE);
            queue = session.createQueue(queueName);
            consumer = session.createReceiver(queue);
            logger.info(”Waiting for message (max 5)”);
            for (int i = 0; i < 5; i++) {
                Message message = consumer.receive();
                processMessage(message);
            }
            logger.info(”Closing connection”);
            } catch (Exception e) {
                logger.error(”Caught: ”,e);
            } finally {
                consumer.close();
                session.close();
                connection.close();
            }
        }
    }
    public void processMessage(Message message) {
         try {
            TextMessage txtMsg = (TextMessage) message;
            logger.info(”Received a message: ” + txtMsg.getText());
         } catch (Exception e) {
            logger.error(”Caught: ” , e);
         }
    }
}

The sender class

import java.util.logging.Logger;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage

import org.activemq.ActiveMQConnectionFactory;

public class JMSSender {

    private Queue receiveQueue = null;
    protected String queueName = “SendReceiveQueue”;
    protected String url = “tcp://localhost:61616″;
    Logger logger = Logger.getAnonymousLogger();

    public static void main(String[] args) {
        JMSSender msgSender = new JMSSender();
        msgSender.run();
    }

    public void run() {
        QueueConnection queueConn = null;
        QueueSession queueSess = null;
        TextMessage myMessage = null;
        QueueSender queueSender = null;

        try {
            ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(url);

            queueConn = factory.createQueueConnection();
            queueSess = queueConn.createQueueSession(false,Session.AUTO_ACKNOWLEDGE)
            receiveQueue = queueSess.createQueue(queueName);
            queueSender = queueSess.createSender(receiveQueue);
            myMessage = queueSess.createTextMessage();

            myMessage.setText(”test from JMS client 2″);
            queueSender.send(myMessage);

        } catch (Exception e) {
            logger.info(”Caught: ”, e);
        } finally {
            queueSender.close();
            queueSess.close();
            queueConn.close();
        }
    }
}

Why develop Java applications on Mac? Well, why not? Aside from the coolness factor, here are some business and technical reasons to do so.

• Macbooks are faster and more stable than any other Vista machine.
• Macbooks can run multiple OS - Linux, Windows and Leopard. With VMWare or Parallels, you can even run Windows within your Mac environment.
• You have a better brand than any other outsoucing or software development company. Imagine sending 5 consultants to your clients each carrying a Macbook.
• They have the tools needed for Java development - including Eclipse, MySQL, Xcode and any other Java IDE.
• The graphics interface is inspiring. Who says developers don’t need inspiration?
• Prices of software (e.g. iWorks, etc.) is cheaper than its Microsoft counterparts. Besides, most of the tools are open source.
• Prices of Macbooks are competitive if not cheaper than other laptop brands.
• It’s secure… it’s built on top of BSD.
• Did I mention NO virus?
• The coolness and intuitiveness of Time Machine encourages data backup. The video below is available now in Leopard and it works!

Mac OS X Leopard - Time Machine

Like most of us often hear, “its another framework or dependency management tool”. But what exactly differentiates Ivy from Maven?

Ivy is much easier to use. The library is simpler since it doesn’t do so much. It only focuses on dependency management and use the already famous and powerful ant to build the application. In short, ant and ivy is used side by side.

Why I Choose Ivy?

The main thing I like about Ivy is its simplicity. You can use Ivy with only ant installed on your system (and of course, java). This means that you don’t need to download any Ivy related libraries or when using eclipse, no plug-in is needed. You can run everything using ant, from installing the ivy library to downloading the dependencies.

Ivy is a dependency management tool that can use other repository such as maven repository.

Installing Ivy

Before continuing, I’ll assume that you are using ant version 1.7. You can choose to run the ant script in either console or from inside eclipse (It depends on your preference).

Here is a build.xml file that contains several targets that will be used in this post:

<?xml version="1.0" encoding="UTF-8"?>

<project name="ivytest" basedir="." default="usage" xmlns:ivy="antlib:org.apache.ivy.ant">

<property name="lib.dir" value="lib" />
<property name="build.dir" value="build" />
<property name="src.dir" value="src" />

<path id="lib.path.id">
<fileset dir="${lib.dir}" />
</path>

<path id="run.path.id">
<path refid="lib.path.id" />
<path location="${build.dir}" />
</path>

<property name="ivy.install.version" value="2.0.0-beta1" />
<property name="ivy.jar.dir" value="${basedir}/ivy" />
<property name="ivy.jar.file" value="${ivy.jar.dir}/ivy.jar" />

<target name="usage" description="Displays the command used with this build script">
<echo message="Usage" />
<echo message="-------------------------------------------" />
<echo message="Available targets are:" />
<echo message="download-ivy --> Download ivy library" />
<echo message="install-ivy --> Install ivy library" />
<echo message="clean-libs --> Delete lib files" />
<echo message="clean-ivy --> Delete the ivy files" />
<echo message="resolve --> Resolve/Download ivy dependencies" />
</target>

<target name="download-ivy" unless="skip.download" description="Download ivy.jar">
<mkdir dir="${ivy.jar.dir}"/>
<echo message="installing ivy..."/>
<get src="http://repo1.maven.org/maven2/org/apache/ivy/ivy/ ${ivy.install.version}/ivy-${ivy.install.version}.jar"
dest="${ivy.jar.file}" usetimestamp="true"/>
</target>

<target name="install-ivy" depends="download-ivy" description="Install ivy library">
<path id="ivy.lib.path">
<fileset dir="${ivy.jar.dir}" includes="*.jar"/>
</path>
<taskdef resource="org/apache/ivy/ant/antlib.xml" uri="antlib:org.apache.ivy.ant" classpathref="ivy.lib.path"/>
</target>

<target name="clean-libs" description="Delete all libraries/dependencies">
<echo message="Deleting ${lib.dir}" />
<delete dir="${lib.dir}" />
</target>

<target name="clean-ivy" depends="clean-libs" description="Delete the all folders/files that was generated by ivy">
<echo message="Deleting ${ivy.jar.dir}" />
<delete dir="${ivy.jar.dir}" />
</target>

<target name="resolve" depends="install-ivy" description="Resolve the dependencies">
<ivy:retrieve/>
</target>

<target name="run" depends="resolve" description="Compile and run the project">
<mkdir dir="${build.dir}" />
<javac srcdir="${src.dir}" destdir="${build.dir}" classpathref="lib.path.id" />
<java classpathref="run.path.id" classname="Main"/>
</target>

</project>

Invoke “ant install-ivy” and the ivy jars will be downloaded. A new folder named “ivy” will be created with the ivy.jar in it.

Dowloading Dependencies

By default ivy uses maven 2 repository but you can certainly define other repository (It will be covered on later post).

The build.xml above contains a target named “resolve”. Running the target will cause the Ivy to download defined dependencies on ivy.xml (ivy.xml is needed since all the dependencies are defined on that file). Here is an example of ivy.xml:

<?xml version="1.0" encoding="UTF-8"?>

<ivy-module version="2.0">
<info organisation="ideyatech" module="ivytest"/>
<dependencies>
<dependency org="log4j" name="log4j" rev="1.2.8"/>
</dependencies>
</ivy-module>

The code above downloads the log4j and its dependencies from the defined repository (in our case, maven repo). I chose to use log4j because in the next section, I’ll be demonstrating to compile a simple java class that uses a Ivy managed library. Invoke “ant resolve” now and you will see a message saying that the library is being downloaded.

Compiling The Application

Main.java:

import org.apache.log4j.Logger;
public class Main {
    private static final Logger log = Logger.getLogger(Main.class);
    public static void main(String[] args) {
        System.out.println(”Printed using system.out.println”);
        log.info(”Printed using log4j logger”);
     }
}

The sample java file won’t really print the message being logged. The purpose of this example is to test compiling the application with the Ivy libraries being referenced. The idea is to simply add the “lib” dir to the classpath on compilation.

Try invoking “ant run” and the application will be compiled and executed. Note that invoking the “ant clean-libs” and removing the “resolve” dependency on run target will cause the compilation to throw some error.

References:

http://ant.apache.org/ivy/index.html

Note:

• Ivy logo is property of Apache Ivy and is not connected with Ideyatech.

Today, we attended the Sun Tech Days Conference at the Makati Shangrila. Aside from the great food and freebies, I enjoyed the whole experience. There were several things I learned during the second day of the 3-day conference. Here’s to recap what I learned and observed:

• Java 6 has some nice features including Scripting Language Support (JSR 223) and Web Service Integration. I agree that these 2 features are very common and should be part of the standard Java. I’m not sure about JDBC 4.0; with the success of JPA, JDBC might not be that useful anymore.
• Grails is cool, but not necessarily great. I think it still needs improvement to be able to compete in the enterprise, if at all possible. My main concern with template codes is “customizability”. But it’s still cool.
• Sun admitted their problems with Java 6, such as slow start-up and large codebase. I think this is a good sign for the future of Java.
• Netbeans has improved since I switched to Eclipse three years ago. It supports a ton of platforms/frameworks and has a lot of productivity tools. I believe Netbeans is probably worth revisiting.
• Half of the conference attendees are going to the Enterprise track, which means there is more demand for web applications development rather than desktop (Swing, SWT) or system administration.
• The “new” technologies that the speakers discussed were the same technologies two years ago. We have been already using these technologies (such as Ajaz, JPA, and ESB) in our projects. Either Sun didn’t do a good job in looking for resource persons, or Ideyatech is just updated with the latest technology! (The latter is most probably true… hehe) Anything else new?
• Open-source is confusing - everyone else wanted to be the best platform/framework, and developers are confused which one to use. Even Sun promotes several conflicting/competing technologies - Seam vs. Grails vs. JSF, JDBC vs. JPA, GlassFish vs. JWS. With the myriad of platforms available, which one works best?

]]> http://www.ideyatech.com/2008/06/sun-tech-days-2007-2008/feed/ http://www.ideyatech.com/2008/06/continuum-vs-hudson/ http://www.ideyatech.com/2008/06/continuum-vs-hudson/#comments Sat, 14 Jun 2008 16:16:22 +0000 Allan Tan http://www.ideyatech.com/?p=127 We’ve been using Continuum for quite some time now. While Continuum does seem to do a good job managing our builds, its limited support for JUnit Test reports made us evaluate an alternative, Hudson. Hudson is the new guy on the block, aside from cool icons and more intuitive interface, this tool seems to be quite competitive and feature-packed.]]>

We’ve been using Continuum for quite some time now. While Continuum does seem to do a good job managing our builds, its limited support for JUnit Test reports made us evaluate an alternative, Hudson. Hudson is the new guy on the block, aside from cool icons and more intuitive interface, this tool seems to be quite competitive and feature-packed.

So, I’m listing down a head-to-head comparison between Continuum and Hudson as we’ve used them and based on features we are looking for:

Build Management:

Continuum seems to perform better in this area. It allows multiple jobs/script configured on a single project. Projects can also be logically grouped. Hudson only supports one job per workspace, which I find very limiting. This means that if we need 3 jobs (e.g. build-war, deploy, run-test), each job needs its own workspace, which doesn’t make sense because all these job share the same source code.

User Management:

I prefer Hudson a little over Continuum because I like simplicity over flexibility. Considering our small team size, there is no point of grouping people with several permissions across multiple projects. All we need is the ability to restrict the developer’s access within their projects. Hudson has a simple, easy-to-use permission system–I was able to setup user access rights within 30 minutes. Continuum seems to be a little over-complicated on this. Continuum also has a strict password policy which makes it more difficult to manage.

Scheduling:

Once again, Hudson is better due to its simplicity. To configure a schedule, simply add “@daily” on schedule option and you’re all set. While Continuum’s scheduling isn’t complex, there’s more clicking involved. Again, Simplicity over Flexibility.

Email Alerts/Notification:

Although both tools provide email support, Hudson has a more detailed email report. Hudson allows the tracking of JUnit test reports for every test, while Continuum only provides notifications on failed or successful builds.

In the end, we decided to switch to Hudson because it is easier to use and it includes the Junit test reporting feature.

Note: The Continuum and Hudson logos are properties of Apache Continuum and Hudson, respectively.

I left Manila to see if there was a market for my SMS appliance product. I had to take a job so I can stay and have time to study the market. After working in Singapore for 2 1/2 years, I finally realized that it was the right time to go home. I still have this feeling of competing in the global scene and make my country proud so I looked for opportunities to come back. On the course of doing this, I met Allan, President and CEO of Ideyatech. When we first met, I just told him about my SMS appliance product, on how he can integrate it to Ideyatech’s existing applications.

After maybe 4 months, Allan told me that he needed someone who can help him with one of his big projects. I can’t remember how he came up asking me if I could help. After a few conversations about what needs to be done and how hard it is to look for senior guys in Manila, I expressed my intent of thinking about the offer. Since I was also considering of going back and do business, I thought about it. It took me maybe a month to decide.

I arrived with my bags packed in the Centennial Airport(NAIA Terminal 2) on May 21, 2008. Eager to meet my new team, I went to work the following day. It’s nice to be back, I told myself.

Let me share a photo of our team in our board room which I took. This is the team that will lead us to success and grow the company. Who knows we might be the next Google!

As recommended by Yahoo on YSlow - tip #1: Make fewer HTTP request and tip #10: Minify javascript- we aim to implement these tips on all our projects with minimal head-ache. While these recommendations are truly useful, implementing them can be quite tedious and challenging. Consider having to maintain multiple min versions of the javascript and the files that links to them! So to alleviate the problem, we created a tool called low-tides (as part of open-tides) that helps automate the merging and minification of css and js files.

So what is the rationale behind the the tool?

• Maintenance of minified js and css is a nightmare. Keeping separate js and css files for development and production can be very confusing. Some developers might change the production version without syncing with the development version. So eventually, changes to different files becomes a mess — Which one has the latest code?
• Maintenance of html files that links to proper javascript and css is another problem. Since minified versions are likely to have different filename (e.g. basic-min.js), html codes that reference the scripts need to be changed. This leads to having multiple copies of html files… again.
• Versioning of html, css, and js files introduce a whole new set of configuration items. Imagine bullets #1 and #2 getting multiplied across a number of version releases!
• At the time of this writing, there are no tools available that can merge multiple javascripts. The development version of javascript needs to be logically separated while the production version needs to be merged (for lesser http request). Moreover, merging javascript is not straightforward. Some javascripts need to be pre-loaded while others can be postponed.

I suppose by now you get the picture. The solution we propose to this configuration problem is simple:  Always change from the development version and have a deployment script automatically create the production version. As such, files are always maintained from the development version - but the key to this approach is to ensure that the script for creating production versions is quick and easy-to-use.

Now here comes Low-tides. Low-tides is a Java-based program that automatically analyzes html files for javascript and css includes. It will merge includes that are in sequence into a single file and minify it. In summary, it automatically solves all the problems mentioned above.

You can download it here: http://code.google.com/p/open-tides/downloads/list

Usage instructions are available here: http://code.google.com/p/open-tides/wiki/LowTides

How do stand-up meetings help? Are they really helpful?

Here at Ideyatech, we have been practicing stand-up meetings religiously ever since our first project. So far, this short, daily routine has kept everyone up-to-date on status of their projects. By reporting daily activities, issues and bottlenecks are quickly identified and resolved. Everyone gets accountability on the tasks that are reported, and the team becomes more responsible of the project as a whole.

Here are some tips to make stand-up meetings effective:

1. Be religious. Make it a daily habit.
2. Keep it short. Do not exceed 15 minutes.
3. Avoid autocracy. Let team members take responsibility and accountability.
4. Break long conversations. Take it offline and discuss after the meeting.
5. Use a small object as a token indicator of the current speaker. We use a ball, which occasionally brings some fun during meetings.

In addition, here are some common problems we encountered during our stand-up meetings:

1. Some members (especially the younger ones) tend to report to the project leader, instead of reporting to the team.
2. Some members wait for the stand-up meetings before bringing up their questions or issues.
3. Most of the time, the members report only their accomplishments, and tend to forget about the problems or their pending or next tasks.

At the end of the day, these stand-up meetings serve as a medium for communication between project members. For best results from these stand-up meetings, some procedures may need to be applied and laid out.

As defined in Wikipedia:

Agile Software Development is a conceptual framework for software development that promotes development iterations, open collaboration, and adaptability throughout the life-cycle of the project.

True to its meaning, Agile is a concept that can be implemented in several ways. So, there is no correct way of getting it right… Nevertheless, here are some tips we’d like to share based on our experience:

1. Agile team members must be matured and responsible. Team members must be pro-active and have the drive/determination to take charge of the task at hand. Self-organizing teams are hard to develop, especially for junior programmers. It takes some level of maturity and experience for a team member to identify the tasks and execute them.
2. Agile projects must be contracted as “Time and Material” rather than as “Fix Cost”. This is because agile practice is susceptible to “scope creeps”. The concept of being able to adjust/change requirements during each release indicates that scope must be flexible. As such, contracting on “fix cost” will either limit scope changes or lead to tedious change control processes.
3. Pair programming should be limited. It is effective only on certain circumstance such as “master-apprentice” pairing or critical components. Otherwise, it will lead to inefficiency where two people are producing half the value of their time.
4. Tools are essential for unit testing and continuous integration. It is almost impossible to implement unit tests and continuous integration without the proper tools to support the build and test process. It is important that the tool is able to run builds on pre-determined schedules and send configurable alerts. Moreover, choose a tool that can understand the unit test results and do notifications as necessary.
5. Take the Agile Manifesto with a grain of salt. Not everything in Agile works… it varies on the organization, software and project type. For organizations that are new to this concept, start by shortening your iteration release - at least to monthly. This can take you a long way going agile…