Many tech startups are averse to outsourcing the development of their products because they do not fully grasp the dynamics of working with third-party providers.

What if you have the killer idea but do not have the technical capability to produce it? Is it possible to outsource the technical development of your product? The short answer is yes, specially if you have limited budget and resources. But you’ll need to consider some important factors beforehand. Below are some of them:

1.) Determine the minimum viable product (MVP). The MVP is a core component of Lean Startup that aims to simplify your solution to the problem and allows you to deliver your product quickly. MVP is a strategy to ensure that you do not build features that your customers do not want. First, develop the core functionality of your product. Second, release your product and test the market. Finally, get feedback and evolve.

Do not start outsourcing your development efforts without a clear MVP – you will find your development team working on unnecessary features. Given that you have limited resources, clearly it is a waste to work on the non-essentials.

2.) Ensure IP protection. Make sure that proper protection clauses for the intellectual property are clearly specified in the contract. That is, all IP resulting from the outsourcing arrangement belongs to you. Also, make sure that you are aware of all third-party libraries used and their license agreements.

3.) Start with a prototype. Consider working on user experience from the very beginning. Most, if not all, of modern applications are user-centered. Starting your work with a prototype not only allows you to validate your design, it also ensures that your outsourcing partner understands the requirements correctly and is capable of delivering on the job.

4.) Keep R&D. If you are trying to solve a problem where the solution is non-existent or if you are trying to develop advanced algorithms, do not expect your vendor to develop the solution for you. Keep research and development work with your internal team.

4.) Find the right technology partner. Ensure that your provider has the right skills and experience for the project. If you are developing multi-tenant applications, check their background and experience in working with multi-tenancy. If you are developing mobile applications, then check their related work, if available. Ensure that your vendor understands the startup environment, its technologies, opportunities and challenges.

5.) Adopt the agile methodology. You want your product to evolve quickly and your team to adjust quickly. To this end, ensure that your team is capable of delivering product features within weeks and not months. Check that your provider has the right tools such as agile-compatible tracking systems, continuous integration tools, as well as experience with automated and unit test practices.

6.) No fixed cost contract. Since your requirements will evolve, only engage on a time and material billing arrangement. Fixed cost contracts will not work for dynamically changing requirements. Either you end up paying more, or the vendor suffers from scope creep. Either way, it is not going to be a long-term relationship.

7.) Drive the product but share the “sense of ownership”.  Even when you solely own the product, you can still make the team feel like they’re part of the product and its success. Ensure that you are driving the requirements but also make sure that the team is aware of the problems you are trying to solve. Explain the situation and ask for their opinions.

Ideyatech is a Java development firm that has successfully developed several startup projects like Stalkthis, Skedly and more. Feel free to contact us at info@ideyatech.com.

Software Testing is an unlimited dimension on software development. Countless possibilities can be executed and tested on software testing. With limited time and resources, how can a tester maximize his effort through these limiting factors? Let’s take a look on some tips on how a Tester can test effectively:

1. First things First – High Priority Bugs should be prioritized on testing. These bugs have greater impact on the system and usually, it takes up more time in terms of testing. Mainly due to the complexity of the bug or perhaps the level of significance of it to the end-users.
   
   
2. Descriptive Bug Reports – Creating clear and straight to the point Bug Reports can reduce iterations within the team. Further clarifications between Testers and Developers that consumes Time can be lessened if the Bug Report is easy to understand.
   
   
3. Pessimist Thinking – It’s important to bear in mind that there is always a loophole in the system. This drives the tester to have the strong intention of finding bugs but;
   
   
4. Know When to Stop – There’s no perfect system, but at least, try to reach near it. If the system had already complied with the requirements and the certain level of confidence has been reached, then the testing can be halted.
   
   
5. Communicate Well – When you’re talking with Developers, make sure that you discuss issues to them clearly. It’ll reduce discussion iterations, provides smooth conversations and improves your credibility as a tester.
   
   
6. Test beyond Requirements – After checking the software if it’s complied with the requirements, it is good to check what the system can do beyond the specified requirements. Bugs usually appear on this process.
   
   
7. Automated Test Cases are like Software – that should be maintained. Changes are inevitable thus modifications on scripts and test cases should be done to enable your test cases be useful through time and system revisions.
   
   
8. Think on Idle Time – It’s a good opportunity to formulate test scenarios while waiting for the upcoming bug fixes to be tested. Read the requirements or specifications and let your mind wonder. With this, ideas will eventually pop-up like mushrooms.
   
   
9. Have a Break! – Sometimes software testing could be a monotonous process and you’ll start to feel being burnt out. Take a break and let your mind relax for a while. This can do wonders as it helps your mind to shake its stress away and get back on track again.
   
   
10. Raise Questions – A Creative mind will always have the output in the form of Questions. “Why is that..?”, “How come that..?”, “What should be..?” are some of the questions that a tester should ask. Though it’s a rule of thumb for us to get justice on each of our questions regardless how important or how silly it would be, just make sure that each of your questions has a good point to tackle. Or else, those questions won’t be entertained.
    
    
11. Join Online Forums – It’s nice to have buddies who you can ask and share a thing or two about Software Testing. No matter what you are in the forum, you’ll still definitely get something. If you just wander around, you’ll get information. If you help answering questions, then that can sharpen your knowledge. If you ask, then you’ll be given answers that you needed.
    
    
12. Sharpen yourself – Attend Software Testing Trainings, Seminars or even take Certifications such as ISTQB certification and the likes. Undergoing these activities can sharply amplify your Software Testing skills thus greatly improving yourself as a Software Tester.
    
    

Aside from these, don’t forget to enjoy the pleasure of having a work like Software Testing. It’ll be your source of passion to keep you going every day. Happy Testing!

So, how can you encourage users to populate data fields as complete as possible?

Try the gamification concept which we refer to as “data completeness” – which is actually patterned after Linked-In’s profile completeness.

This is one of the latest feature we added to our product – Attaché. This feature keeps track of the completeness of data inputted on a case profile and assign a percent complete based on the data entries.





There are 2 key elements shown from the image above. First is the percentage value with maximum of 100% and second is the list of suggestions to increase the percent completeness. Other key elements in implementing this feature includes:

• Ability to roll-up the percentage to per user, per group level so that supervisors and managers can see who provides more complete information.
• Ability to customize the rules for computing the percentage because different rules can be used depending on the type and status of the record. For example, a record mark as “closed” should have the exit data.

Here are some of the user’s feedback after rolling out this feature:

• I like it because it provide suggestions how to increase the percent complete.
• I want all cases (records) with me to reach 100% complete all the time.
• Great! This makes everyone fill-in the same level of data completeness on all our cases.

Clearly, this feature works great because it does not enforce rather it encourages.

The trip to Graphika Manila was definitely worth it. It was generally fun and inspiring. The speakers were really great and we learned a lot from them.

Here are few of the things we learned from the conference:
 

 
What Jessica is trying to say here is you have to enjoy work. Work doesn’t always have to feel like work, it can feel as if you’re just playing a game. Whenever work feels like work, just hit the pause button and think of how you can make things a bit more interesting. (Maybe put the computer to sleep and start doodling a web interface.) That way, you become more creative and you never have to work a day in your life.
 

 
To be creative, you have to challenge yourself. Take risks because it’s better to have Oh wells than What ifs. Don’t be afraid to make mistakes because you’ll learn from them.

Many of us forget why we started as developers… and the reason is so simple; We just love making cool things with our hands. Graphika Manila reminded us of that.

Software application development is similar to any form of art. You think of something amazing, build it and inspire people to do the same.

Grid System

Bootstrap is based on a 940px wide grid on a 12-column layout, which gives an easy way of making templates.

CSS Components

It offers different set of classes that are commonly used as elements in creating interface design. It also delivers a better approach to formatting; from Typography, Tables, Forms & Buttons, Navigation, Alerts, and Progress Bar to a package of free Icons.

Here are some of the components of Twitter Bootstrap: (click image to enlarge)

Responsive Web Design

Listed as one of the Top Web Design Trends of 2012*, Bootstrap has presented their own approach to the idea of giving a user the finest viewing experience. It is a concept of enhancing a web design to adapt in different devices, be it on desktop, laptop, tablet or smartphones.

Javascript plugins

The javascript components of Bootstrap are based on the jQuery Javascript framework. It has 13 supported plugins, which are Modal, Tooltip, Collapse, Carousel, Typeahead, Dropdown, Scrollspy, Tab, Popover, Alert, Button, Transitions and Affix.

Customization

Bootstrap gives you the control to choose the components that is necessary to your design concept and let you customize variables based on your preferred style.

So basically, designers and developers will benefit from Twitter Bootstrap. A developer alone will be able to achieve a functional layout provided by properly identifying the CSS components even without a visual designer. And as for the designers, it serves as a guide in executing stylish designs.

Twitter Bootstrap is open-source and one that is getting its name when it comes to Responsive feature. Since responsive web design is becoming popular, Bootstrap is able to respond to this trend in developing websites in a fluid behavior. It will give a new meaning to a modern website by providing a professional-polished look and a divert edge of a simple-sleek style.

*based on .net magazine

References:

• http://twitter.github.com/bootstrap/
• http://en.wikipedia.org/wiki/Twitter_Bootstrap
• https://dev.twitter.com/blog/bootstrap-twitter
• http://webdesign.tutsplus.com/tutorials/complete-websites/twitter-bootstrap-101-introduction/
• http://www.slideshare.net/julienrenaux/introduction-to-twitters-bootstrap
• http://www.w3resource.com/twitter-bootstrap/responsive-design.php

The party was a fun-filled gathering highlighted with sumptuous food, lucrative raffle prizes, fashion-inspired special awards and spectacular performances by uberly confident bunch of employees.

Here are some of the outtakes from that great night.

(Photos By: Mr. Raymond Lopez)

Happy Holidays from Ideyatech

The operations at the Court of Appeals have recently been modernized through the use of a new Case Management Information System (CMIS).

CMIS is a web-based system that consolidates the operations of the appellate court into one easy-to-use and intuitive interface, backed by a singular central database. The system features solutions that are designed to enhance the court’s efficiency and transparency.

As you can see, there are several steps in building an application. Building an application manually is no longer advisable. This is why build tools were introduced. Sample of build tools are Ant, Gradle , our IDEs and Maven. In this article, we will focus on using Apache Maven for building a Java application

What is Apache Maven?

Maven is considered by many only as a build tool. Maven, as defined by the project’s website, is a project management and comprehension tool. Aside from helping on managing a build, maven is also useful in documentation, reporting, managing dependencies, SCMs, releases and distributions.

This blog will only focus on using Maven as a build tool. We will see how Maven is used in creating a Java application, testing it through unit tests, building/packaging the application and then finally deploying it.

Maven’s Objectives

Maven’s objectives are as follows:

mvn phase

mvn goal

To create a Maven project, we need to first understand the concept of archetype. Archetype is defined as a pattern or prototype upon which others are copied or patterned. In Maven, archetype is a project templating toolkit. This allows other developers to create project template that other users can use. Archetypes currently available ranges from the simplest to the more complex applications. Sample archetypes are archetype for creating a web application with Hibernate, Spring and Spring MVC, archetype for a simple Java web application, Groovy basic archetype, etc.

To create a maven project, just run the following command: mvn archetype:generate This command will enable you to create a maven project using the interactive mode, that is you will be able to choose the archetype to use, the version of your project, and other necessary information for the project. To create a simple web application, run the following command:

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-webapp -DarchetypeArtifactId=maven-archetype-webapp

Maven Standard Directory Layout

Maven suggests a standard directory layout for all maven project. This will allow developers to easily navigate with another Maven project once they are comfortable with the standard. Shown below is the directory layout expected by maven.

Maven POM

After creating a Maven project, notice the file named pom.xml. POM stands for Project Object Model. This is an XML representation of a Maven project. It can contain all the necessary information you need for a Java project. A minimum pom.xml file is shown below:

	4.0.0
	org.ideyatech.group
	my-project
	1.0

1. groupId – a unique ID for an organization or project.
2. artifactId – the name of the project
3. version – the current version of the project

Maven also helps developers to manage the project’s dependencies. One advantage of using Maven is developers just need to specify the libraries they need. If those libraries have their own dependencies, called transitive dependencies maven will automatically download them. You can specify a dependency using the following:

	
		junit
		junit
		4.0
		jar
                test
	

1. groupId, artifactId, version – the same definition as creating a new Maven project
2. type – the artifact’s packaging type. This defaults to jar.
3. scope – refers to the classpath of the task at hand. Defaults to compile.

Compiling application sources can easily be done by executing the phase: mvn compile.

To execute unit tests we need to first add the following plugin:

   org.apache.maven.plugins
   maven-surefire-plugin
   2.11
   
    
     **/*Test.java
    
   
  
 

Notice the include tag. This tells Maven to only include all test classes with name ending with Test. Then to run all tests just invoke mvn test

You can specify the packaging of your application in the packaging tag of your pom.xml file. Since we are working with web application, the packaging should be war. To package a maven project, we just need to execute the command mvn package.

To deploy an application in a running Tomcat instance, add the following plugin:

 org.codehaus.mojo
 tomcat-maven-plugin
 
  http://localhost:9090/manager/html
  user1
password
  true
 

• url – the url of the tomcat manager
• username – username that will connect to the tomcat manager
• password – password of the username

Then just invoke the command: mvn tomcat:deploy

Here’s a rundown of what we learned:

Google App Engine

GAE is a true cloud hosting because it charges by CPU cycle instead typical by CPU instance. This also implies that your application is running on a scalable and elastic platform. The performance of your application automatically adjusts to the load. However, as a trade-off, your application needs to be designed and built based on GAE from the start. Existing Java applications may not be compatible with GAE due to limited library support for Java.

In our case, we had trouble getting our existing Hibernate/JPA to run in GAE because some of our functionalities are tightly-coupled with Hibernate API. So, we quickly dropped GAE as an option.

Amazon Elastic Beanstalk

Amazon Web Services offers a wide variety of cloud hosting services which makes it the leading cloud provider. However, this also makes AWS very difficult to understand. After logging in, I was bombarded by the navigation tabs as shown below (there’s actually more that couldn’t fit this screen).

Understanding each of the service and picking the right service requires considerable amount of learning time. Setting up security for interconnectivity between my console to the virtual machines to the database is also not very straightforward.

In our case, it took me about 2 days to deploy our application. This is primarily because I have to learn and understand the different configuration settings and choose the appropriate one. The good news though is that we are able to successfully deploy our enterprise application in the Amazon Cloud and has been very stable so far.

Cloud Foundry

Cloud Foundry is backed by VMWare, Inc. and could be a true competitor of Amazon in the cloud hosting business. They offer hosting for different platforms as well including Grails, Node.js, Ruby and others. Deployment is relatively straightforward. We were able to get our application working but had problems on the database because we are unable to change lower_case_table_name settings in my.ini. Unfortunately, we can’t rename all tables because we have production data already.

Jelastic

Jelastic is a new player in the cloud and they offer hosting that is specific to Java. This gives a great deal of advantage for Java developers to easily move their application into a cloud based service. During the time of our evaluation, Jelastic was in BETA and is not ready for production use. Nevertheless, I see a very good fit of our Java application into Jelastic because they support Tomcat and Mysql.

Unfortunately, we had trouble uploading our database into Jelastic because they only allow uploading of limited file size during the BETA period and our database was about 200MB. It may be worthwhile to try Jelastic again since they are now in production.

Conclusion

We ended up choosing Amazon ElasticBeanstalk as our hosting provider because they offered the most flexible hosting option. With Amazon AMIs, we were able to setup our application according to our needs. If given another chance to build a new cloud application, I would be happy to explore Google App Engine.

Enterprise applications usually consists of multiple layers. Primarily presentation layer, business logic layer and persistence layer. The business logic layer is considered the heart among these layers, and this is where all processes and decisions take place. Requirements for this layer also changes more often than the rest of the application. As requirements continues to change, it is very easy for the code in this layer to end up tangled in a situation known as “spaghetti code”, lots of nested if-else conditions, and as new conditions are added, readability suffers. Moreover, to change the behavior of the system, a recompile and rebuild must be done.

This post aims to introduce the Business Rules Approach, a development methodology where rules, decisions and processes are used by, but does not have to be embedded in business process management systems. You’ll be introduced to this methodology through the use of a business rule engine – JBoss Drools Expert, part of JBoss’ Business Logic Integration Platform.

What are Business Rules?

A business rule is simply a statement that defines or constrains some aspects of the business. Business rules always resolves to either true or false. Business rule can also be defined as an abstraction of the policies and practices of a business organization.

Example:

• A customer can have several reservations but only one car can be rented at a time. (Car Rental)
• When a registration is coming from a country listed in the banned country list, reject the registration. (PTC Site Registration)

What is a Rule Engine?

A business rule engine is the heart of the technology behind the Business Rules Approach. It is a system that evaluates and executes one or more business rules in a runtime production system against known facts (domain models).

Why use a Rule Engine?

• Logic and Data Separation – Your data is in your domain objects, the logic is in the rules.
• Speed and Scalability – business rules engine uses algorithms design to efficiently match rule patterns to your domain objects, for example the Rete Algorithm as used in Drools Expert. Also in terms of scalability, rules can be shared in different systems allowing us to create or integrate sub-systems that uses some of the rules used by other sub-systems.
• Centralization of Knowledge – since logic are externalized in the form of rules, there is only a single source of truth, and that is your repository of rules / knowledge (a knowledge base).
• Explanation Facility – Rule systems effectively provide an “explanation facility” by being able to log the decisions made by the rule engine along with why the decisions were made.
• Understandable Rules – in Drools Expert, rules can be written using DSLs (Domain Specific Languages) allowing non-technical domain experts to write rules which are close to natural language.

Sample Rules

Figure 1: An Example Drools Rule File

Hello Message Rule and Goodbye Message Rule. We can read these rules this way:

• Hello Message Rule – “When the Message object’s status is HELLO, display the message attribute of the Message object and change its message and status to “Goodbye Cruel World” and GOODBYE respectively”.
• Goodbye Message Rule – “When the Message object’s status is GOODBYE, display the message attribute of the Message object.”

Make Your Applications Rules-Driven

Drools Expert is a sub-project of JBoss Business Logic Integration Platform and this is the business rule engine we’ll be using in this post. To make your applications rules-driven using Drools Expert, you need first to understand the following important concepts:

1. Facts – facts are simply your domain objects / models. Rules are run against these facts to match conditions declared in the rules with the state of the fact currently being used and this determines the rule / rules to run.
2. Rule – a rule is a statement that test a condition against a fact and is composed of 3 important sections:
1. Name – name of the rule
2. LHS (Condition) – This is the “when” section (see above). This section declares the condition the rule would test.
3. RHS (Consequence / Action – This is the “then” section (see above). This section declares the consequence or the action to be performed when the condition declared in the “when” section is met.
3. Knowledge Base – a repository of rule / knowledge
4. Knowledge Session – a session is an established interaction between your application and the rules engine. A session is created from a KnowledgeBase and can be either Stateless or Stateful. The application uses the established session to run the engine against the inserted facts.

Sample Code:

package com.ideyatech.drools;

import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.io.ResourceFactory;
import org.drools.runtime.StatelessKnowledgeSession;

import com.ideyatech.drools.bean.Message;

public class Main {

	public static void main(String[] args) {
		final KnowledgeBase knowledgeBase =
			createKnowledgeBase();
		final StatelessKnowledgeSession session =
			knowledgeBase.newStatelessKnowledgeSession();

		try {
			final Message message = new Message();
			message.setStatus(Message.HELLO);

			session.execute(message);
		}catch (Throwable e) {
			e.printStackTrace();
		}
	}

	private static KnowledgeBase createKnowledgeBase() {
		final KnowledgeBuilder builder = createKnowledgeBuilder();
		final KnowledgeBase knowledgeBase = KnowledgeBaseFactory
			.newKnowledgeBase();
		knowledgeBase.addKnowledgePackages(
				builder.getKnowledgePackages());

		return knowledgeBase;
	}

	private static KnowledgeBuilder createKnowledgeBuilder() {
		final KnowledgeBuilder builder =
			KnowledgeBuilderFactory.newKnowledgeBuilder();
		final String rulePath = "com/ideyatech/drools/rule/hello-world-rule.drl";

		builder.add(ResourceFactory.newClassPathResource(
				rulePath), ResourceType.DRL);
		if (builder.hasErrors()) {
			throw new RuntimeException(builder.getErrors().toString());
		}
		return builder;
	}
}

Code Explanation:

• The code above contains two helper methods: createKnowledgeBuilder() and createKnowledgeBase().
• The createKnowledgeBuilder() method creates an instance of KnowledgeBuilder which is responsible for taking source files such as .drl (Drools Rule) files and turning them into a KnowledgePackage of rule and process definitions which a KnowledgeBase can consume.
• In this method we added to the KnowledgeBuilder the rule file “hello-world-rule.drl” which is a ClassPath resource. Take note that rules can also obtained as a File resource or a URL resource.
• The createKnowledgeBase() method creates an instance of KnowledgeBase which is a repository of all the application’s knowledge definitions. This method uses the createKnowledgeBuilder() and gets all knowledge packages from the created KnowledgeBuilder to be used by the created KnowledgeBase.
• In the main method after creating our KnowledgeBase, we then created a StatelessSession and then asked the created session to execute all rules against the Message object with a status Hello.

When we run this code, this produces the following result:

Human-Readable Rules using DSL

In Drools, rules can also be written in a syntax which is close to natural language (English for example). This allows non-technical domain experts to author rules using plain English statements and a few Drools rule syntax which doesn’t require advanced technical knowledge to understand. The example below shows a simple rule written in DSL format.

Figure 2: DSL File

Figure 3: DSLR File

In the above figures, we have 2 files; a DSL and a DSLR file. The DSL file contains the mapping of the conditions and consequences used in the DSLR file. For example, the DSL condition “There is a customer with firstName {name}” is mapped to “$customer : Customer(firstName == {name})”. This mapping / translation simply tells the engine how to interpret the rule written in the DSLR file.

Conclusion

Truly, by using a business rule engine and allowing business rules to drive our applications, we can increase our development agility, improve software maintainability, and allow us to deal much easier with evolving requirement complexity. However, also take note that by introducing business rule engine to your applications, you also add another layer of complexity to your application architecture. Using a business rule engine should be considered when we need to create pluggable systems, expert systems or when the need to handle ever-changing requirements is very high. For application requirements of moderate complexity, the standard approach of embedding logic through imperative programming language may suffice.

References:

• JBoss Drools Documentation
• Drools and JBPM Blog
• Drools JBoss Rules 5.0 Developers Guide
• Drools Developers Cookbook

Version control systems has been an integral part of the software development process in the IT world. Industry players have regarded it as a best practice, and indeed the use of one has become the norm rather than the exception. Much like IDE’s, people understand that the benefits of using one far outweighs the cost or the additional learning curve that comes with using such system.

For years now, Subversion or SVN has been the king of version control systems. Developed by Apache, it has been the go-to system of most developers. However, recently, a new VCS has been making waves, bringing with it a new approach to versioning and the promise of a faster, more powerful and more efficient system. This is Git.

Git was initially designed and developed by Linus Torvalds for Linux kernel. It began after many Linux kernel developers chose to give up access to the proprietary BitKeeper system. Primarily developed on Linux, Git can be used on other Unix-like operating system. For Windows, a native port called msysgit is available, as well as a GUI client called TortoiseSVN.

HOW GIT WORKS

Git stores and thinks about information much differently than version control systems, even though the user interface is fairly similar. Most other systems store information as a list of file-based changes. It simply stores the set of files and the changes made to each file over time. Git, however, treats data more like a set of snapshots of a mini file system. For every commit, it takes a picture of what the files look like at the moment and saves a reference for the check-in.

To uniquely identify all the files and objects, Git uses SHA-1 hash. In additional to ensuring uniqueness of identifiers, this action also guarantees the integrity of the files as it’s impossible to modify any file without Git knowing about it.

In order to understand how Git works, it is important to know the three states under Git:

1. Committed – means the data is safely stored in the local database
2. Modified - means that you have changed the file but have not committed it to your database yet
3. Staged – means that you have marked a modified file in its current version to go into your next commit snapshot

GIT ADVANTAGES

Git’s most compelling feature is the branching and merging. In most VCS, a branch is basically a clone of the repository in a new directory – Git does not work like that. A branch in Git is in actuality a simple file that contains the 40 character SHA-1 checksum of the commit it points to.

This means that a user can do things like:

• Create a branch to try out an idea, commit a few times, switch back to where you branched from, apply a patch, switch back to where you are experimenting, then merge it in.
• Create a branch that always contains only what goes to production,
• Create new branches for each new feature that can be merged to the master branch later on
• Create a branch to experiment in and either merge that or delete it – without it being seen by others.

Another positive of Git is that everything is in local. There is very little aside from “fetch”, “pull” and “push” commands that communicates in any way with anything other than the hard disk – all operations are done locally. This means that aside from having everything within one’s fingertips always, Git operations are blazingly fast. In fact, it is limited only by the speed of the hard drive. This has been and continues to be the design goal of the application.

Last, but definitely not the least, is Git’s ability to adapt to any workflow. Because of Git’s distributed nature and superior branching system, one can easily implement pretty much any workflow one can think of relatively easily.

It can be the traditional Subversion-style workflow, with one repository acting as central server.

It can be used with Integration Manager workflow, wherein one person acts as the integration manager who commits to the “blessed” repository, and having developers who clone that repository, push to their own independent repositories, then asks the integration manager to pull from their respective repositories.

It can also implement the Dictator and Lieutenants workflow, wherein the workflow is broken down per module. “Lieutenants”, people who are in charge of a specific module of the project, are responsible for merging all the changes for their respective modules. They have their “dictators”, or people who are responsible in pulling the changes from his/her lieutenants and pushing them to the blessed repository. And with Git’s flexibility, it can be set up in any way, from having one dictator for the project, to multiple dictators, and to having one lieutenant per dictator, to multiple lieutenants per dictator.

Whether it be a Subversion-style workflow, Integration Manager workflow, or even Dictator and Lieutenants workflow, Git is flexible and powerful enough to adjust and still maintain its usefulness.

This is just a quick overview of Git – the versioning control system. It barely scratched the surface as to Git’s usefulness, flexibility and usability. In fact, Git offers more complex and powerful functionality such as complex diffing and merging. Indeed, Git has shown that it is a well thought out and designed system which aims to help and facilitate efficient versioning of files and codes. With all its offerings, it is only prudent that industry players take a look at Git and see how it fits their current set-up.

References:

• http://git-scm.com/
• http://blogs.atlassian.com/2012/02/version-control-centralized-dvcs/
• http://whygitisbetterthanx.com/
• http://thinkvitamin.com/code/why-you-should-switch-from-subversion-to-git/
• http://gaveen.owain.org/2008/05/simple-diagram-on-distributed-vcs-hint.html
• http://progit.org/
• http://www.youtube.com/watch?v=8dhZ9BXQgc4

I would like to share some real-world experiences in improving Hibernate and MySQL performance that we have encountered for the past couple of years. Some of the large applications we developed handles about 500 concurrent users on 8 gigabytes worth of data. For such application size, performance becomes a concern and optimal settings are necessary to maintain acceptable response time.

Here are some things you may consider to improve application performance.

1.) Review table indexes. Table index is a basic concept in database. However, as your application and schema grows, checking indexes become more complex and your ORM tool cannot automatically define the indexes for you. To review your indexes, enable show_sql and check the SQL statements if attributes in where clause have proper indexes. Also, review that indexes are created on foreign keys. In short, do not trust that your ORM tool will automatically define the indexes for you.

Note: If possible, make your indexed columns not-nullable. MySQL has better indexing performance on not-nullable columns.

2.) Identify slow-query for optimization. Turn on slow-query-log and analyze, optimize these SQL statements.

3.) Check for n+1 hibernate queries. With show_sql enabled, observe the pattern of SQL statements issued in your application. Whenever you see a bunch of similar SQL statements being executed unnecessarily, you are likely experiencing the n+1 select syndrome – which is a common problem in Hibernate. Review your query operation and consider rewriting it to return only the specific data needed.

4.) Check Mysql server settings. Make sure your Mysql settings (my.cnf) are properly configured. Do not be intimated with these settings because there are really only a few settings that really matters (in most cases). The ones your should review include key_buffer_size, query_cache_size, table_cache_size, thread_cache_size, sort_buffer_size, read_buffer_size.

Note: As a general rule for InnoDB engines, key_buffer_size value should be between 70%-80% of your machine’s physical memory on dedicated database server.

Note: Make sure that you do not exceed your memory settings against the physical memory, otherwise, you will be storing data into the swap memory or ran out of address space.

5.) Use second level cache on read-only entities. Setup second level cache (e.g. eh-cache) on read-only entities (e.g. country, state, etc.). This eliminates the database operation and keeps result in the application layer cache.

In addition to the tips above, you may also be interested in checking the following:

• If your application is slow while the server is barely doing anything, you need to find the bottleneck and one possible bottleneck is your maximum database connection pool size. Check your maximum connection pool size on both Mysql and Hibernate settings. If the value is low (e.g. less than 50) consider increasing it (e.g. more than 100) as necessary.
• If you are using MyISAM, check for table locking. This causes your entire database operations to be queued thereby slowing your server response time. The quickest solution is to switch to InnoDB. InnoDB uses row-level locking instead of table locking.

For this year, Ideyatech has chosen Pangarap Foundation Inc., a non-stock, non-profit social welfare institution based in Pasay City as our beneficiary. The foundation is working with boys ranging in age from 8 to 17, who are in need of special protection as well as with their families. It has been Ideyatech’s practice to have an annual Outreach Activity or Community Involvement, wherein we choose a nonprofit organization/ charitable institutions as our beneficiary. This activity is being promoted by Ideyatech’s CEO, Allan C. Tan – sharing to the community the success and blessings that the company has received.

The said Outreach event was held last January 14, 2012, Saturday at the Pangarap Foundation, Inc. compound in 2503 Taft Avenue corner Escobal Street, Pasay City. Ideyatech Employees and some family members and friends also participated in the said event. Like any other programs, we all started with a prayer led by our QA Lead, Cielo Navarro, followed by a warm welcoming remark from Brother Francis Tanega of Pangarap Foundation. Of course, the program wouldn’t be as fun and as lively if it wasn’t for our gorgeous, fun and energetic host, Leah Daplin.

It was a day of fun-filled activities for everyone, a lot of games has been prepared that made way for the Ideyatechies and Pangarap boys to interact and bond together. Everyone were just so excited and even our CEO, Mr. Allan Tan wasn’t exempted in joining the games. We started the game “The Longest Line” as warm up and it was totally a warm up game for the Pangarap boys! Participants of the game were so excited to win and some of them ended up almost naked laying down their things and clothes to put up the longest line.

The Longest Lineeeeeeeeeee

The 3 – legged Sack Race game even made things more exciting for us, it was a partnership in taking a hop and teamwork to finish and win the race.

Blow and Find the coin

Bring Me

Calamansi Relay, this must be the hardest game we’ve played, for it needs a good timing, focus and strategy.

The fun didn’t just stop there… The Pangarap Boys also showcase their talents and prepared some song and dance number for us. Some kids were just so talented, that even though they are not prepared, they were able to perform when some kids volunteered them!

Of course, Ideyatechies wouldn’t be left behind without showing what we’ve got! We had our representative too for the song number, Samer Valones who sang Jay Sean’s 2012. There was also a dance show down between Mark Anthony of Panagarap and Ideyatechies Rovie Abanes and Joan Lasola ..teaching them how to dougie!

The fun stuff, PRIZES and GIFT BAGS!!!!!

After giving away the gift bags, we then asked one of the Pangarap Boys, Mark Anthony to share his story to us, how he got there at foundation and how he is doing now. An Inspirational message from Sir Allan Tan was imparted to the kids. Encouraging them to continue dreaming and pursue their studies and that there would always be people who are very much willing to help and support them and their families to have a positive future.

During Lunch time, we got the opportunity to mingle and get to know more about the children, their stories, how they got in the shelter, how they got separated from their family, their ambitions, what they feel now that they are being taken care of at the shelter. The experience of getting to know them more was very heart-warming and an unforgettable one. Although we all have our own drama in life, I was just reminded and made me realized that I am far too lucky to have a family like mine who provided almost everything needed and wanted.

This Corporate Social Responsibility activity by Ideyatech, gave us the opportunity to take part with the responsibility to our less fortunate brothers and sisters. Giving us self fulfillment in being a blessing and an inspiration to these children is indeed a wonderful experience.

These children from the Pangarap foundation will also serve as our inspiration in performing well at work and to be able to be of help to them or to the community.

“Sometimes small things we do can mean everything in another person’s life.”

“CMIS/SC2MS Platform Technologies” focused in giving the attendees a background in using the technologies and framework used to develop the CMIS/SC2MS systems. Topics covered in this class included JPA Using Hibernate, the Spring Framework, Spring MVC, Open-Tides and Jasper Reports. The trainees were provided lecture handouts containing the presentation slides, along with an exercise manual with activities to support the lectures. The class consisted of a mix of lectures, discussions, and exercises. Lecture handouts containing the presentation slides were provided to the trainees, along with an exercise manual with activities to support the lectures.

Last June 2011, Ideyatech launched the first of this three-part training program, entitled “Java on the Web,” that focused in giving the attendees a background in using Java for web development. This class spanned 6 days and covered 3 major topics: basic Java concepts such as exception handling, collections, inheritance, encapsulation and naming conventions; basic web development concepts such as HTML, XHTML, CSS, YUI Reset-Fonts-Grids and JavaScript; and, Java web development concepts such as servlets, JSPs and JSTL.

Before the end of 2011, Ideyatech would have held the third and last part of the training program, entitled “Working with SC2MS/CMIS”. The focus of this class is to provide specific knowledge on SC2MS/CMIS implementation as well as exercises towards the maintaining of the system. This class will span 4 days and will be held at the site/office of the attendees. This class will focus on the application design, enhancements, and troubleshooting of their system.

These three parts comprise Ideyatech’s first training module effort offered to the public – the first of many more technical training programs for the upcoming year.

Cohesive, readable and expressive, easy to debug, refactor, enhance and easy to unit test. These are the qualities of good software code. However, there are factors which hinders most of us from achieving these. When a software is handed over to a number of developers over the years, code degradation happens. And as bugs starts to show up, in pressure of deadline, most of us settle down to quick fixes which adds up to this degradation and code starts to loose its beauty and becomes spaghetti of weak patches.

Good coding practices and regular refactoring may solve this code degradation, but refactoring is sometimes hard to do for some reasons. But if we have coded with testability, cohesiveness and readability in the first place, we would find it easier to refactor later as the need arises.

This post aims to tackle the practice of “Prefactoring” to achieve the good qualities of software code we mentioned above through a practice known as “Programming By Intention“.

Programming By Intention, is not a new concept, most people know this as top-down programming. This technique, in spite of being old turns out to be valuable in an Agile environment.

Let’s say you have a requirement for a software feature wherein you need to create a search engine. The search engine accepts a String as the search criteria. Then you need to extract the tokens from this String (e.g Split the String using space as delimiter) as array then normalize these tokens (convert all characters to lowercase and non-alphanumeric characters must be removed). Then do the search using these tokens. You decided (rightly or wrongly) to come up with one class with a single public method that performs all of these.

Let’s once again review the requirements for the search engine class:

• Accept search criteria in the form of String
• Extract tokens from search criteria
• Normalize tokens
• Search using the normalized tokens

We can call these requirements as intents – abstract description of an operation to be performed.

public class SearchEngine {
     public List<SearchResult> search(String criteria) {
        String[] tokens = tokenize(criteria);
        String[] normalizedTokens = normalizeTokens(tokens);
        return findMatches(normalizedTokens);
     }
}

The methods tokenize(), normalizeTokens(), and findMatches() do not exist yet, but we are already coding it as if they are already in place and since the methods do not exists yet, you are not constrained to anything except your “intentions” (hence, you are “programming by” them). In writing this way, we are allowing ourselves to focus in breaking down the problem and other issues of the overall context.

Programming by Intention says, rather than actually writing the code in each case, instead pretend that you already have an ideal method, local in scope to your current object, that does precisely what you want. And following this advise, you should ask yourself:

• What parameters would this ideal method accept? and,
• What would it return?
• What name would make sense to me right now as I imagine this method already exists?

So what benefits do we gain by coding this way?

• Cohesiveness
• Readability
• Easier to debug, refactor and unit test
• Certain patterns would be easier to see
• Methods are easier to move from one class to another as the need arises

Method Cohesion – cohesiveness is all about singleness. A method is considered cohesive if it accomplishes one single functional aspect of the overall functionality. Looking back at the codes, we basically have a search method which accepts a string as search criteria, and since we did not wrote all logic inside that search method, instead we created methods to do the smaller details of the whole search method, our methods are considered cohesive in the sense that we have a code dedicated for tokenizing, for normalization, and a search worker code. The search() method basically just delegates the actions to our three “helper” methods (tokenize(), normalize(), performSearch()).

Readability and Expressiveness – let’s see again the code and look carefully how easy it is to read and understand what it does.

public class SearchEngine {
     public List<SearchResult> search(String criteria) {
        String[] tokens = tokenize(criteria);
        String[] normalizedTokens = normalizeTokens(tokens);
        return findMatches(normalizedTokens);
     }
}

Resolving Code Smells (We don’t want excessive comments!) – we can see that by coding by intention, we reduce the need for comments because we start by writing methods with sensible names. Misleading and un-updated comments are signs of code smells.

Refactoring and Enhancing – Look carefully at the methods we defined above. All these methods accepts parameters. They do not work on any instance variables containing class may have. Writing methods this way, we reduce the coupling between the containing class and the methods we are defining. If there is change and we now want to create different search engine classes that normalizes tokens the same way, we can easily extract the normalize() method into its own class.

Seeing Patterns – Another change require us to create different kinds of normalizer (e.g LowerCaseNormalizer, WhiteSpaceNormalizer), we can easily change the TokenNormalizer class into an interface and since normalization is considered an algorithm that varies across implementations, we can for let’s say follow the Strategy Pattern allowing concrete classes to implement the normalize() method.

Prefactored codes through Programming by Intention proved to be valuable. It’s an old practice yet effective and you may want to give it a try. As with all practices, getting used to it takes time, but I’m sure most of you can get the hang of it quickly.

Reference: Essential Skills for the Agile Developer, (Shalloway, Bain, Pugh, Kolsky)

For three years, Belvedere Tower in Ortigas has been home for the company. At the time, it was an adequate ground in housing our competitive operation till it can sustain our growing needs no more.

With the accumulated number of employees that has resulted from the number of projects that the company has been currently working on, there has been an ultimate need for a bigger space. Space that we’ve found in a building that also houses the country’s national stock exchange — The Philippine Stock Exchange Centre (PSEC).

The new office is more than 500 square meters, a huge upgrade from our previous 198 sqm lot, located at the 32nd floor of PSEC still at the heart of Ortigas Business District.

It is built with a huge workspace other than the 11 rooms that were dedicated for specific functions:

• 2 Manager’s Room
• Accounting
• Human Resource
• Training Room
• Tomato Room (aka Training Room #2)
• Interview Room
• Orange Room (aka Board Room)
• Lime Room (aka War Room)
• Server Room
• Pantry & Storage

Not only do we have a new office but we also acquired better facilities like our new Digital Scrum Board, complete Server system and mini-library.

Visit our new office at:
3201B West Tower, Philippine Stock Exchange Centre,
Exchange Road, Ortigas Center, Pasig City

More Photos:

Generic types added in JDK 5.0 provided enhancement to type safety in Java. For example in using Collections, generic types allow restricting the type the collection would contain as opposed to pre-JDK5 wherein collection classes accept anything that extends from java.lang.Object (which means almost everything!). And this improvement of allowing types to be specified for collections reduces, if not eliminate, the need for casts and also reduces unexpected ClassCastException at runtime.

Generics also became a key element in Generic DAOs (Data Access Objects) used for ORM driven applications such as those using Hibernate or Toplink.

As beautiful as it may seem, Generics also has its sharp corners which will surely give you several head scratching or even cursing if you are not aware of these Generics traps. The following are some important things to remember when using Generics.

Generics are not covariant.

Most developers might be tempted to think that collections are somehow the better incarnation of arrays and applying the concept of inheritance, some idioms with arrays may sometimes be applied to parameterized collections which turns out not to work the way you think it is.

For example, we all know that arrays are objects. And supposed you have an array of Integer, and since Integer extends Number this is perfectly legal:

Number[] numbers = new Integer[3];

and since all objects in Java extends from java.lang.Object this is also perfectly legal:

Object[] numbers = new Integer[3];

This idiom however if applied to parameterized collections won’t work. The following would not compile.

List<Number> numbers = new ArrayList<Integer>();

Why? Because if the compiler would allow this idiom, it would break the promise of type-safety implicit in the definition of the ArrayList declaration, it is an ArrayList of Integer. That is why Generics cannot be covariant.

Problem with Erasure

The implementation of Generics in Java often described as a crappy implementation is somehow tricky. This implementation is known as type erasure, type-safety is enforced by the compiler at compile time but erases these type information before creating the bytecodes. Because of erasure List<String> and List<Integer> are considered the same class (at runtime the type parameters are already erased and both just exists as raw Lists).

Since compiler removes all type information before the byte codes are generated, suppose you have a class class MyClass<E> { }, these codes will not compile:

public void someMethod(Object item) {
     if (item instanceof E) { . . .} //Fails. Cannot determine type of E

     E e = new E();                  //no way to determine a constructor
     E[] eArray = new E[3];      //fails
}

Constructing Wildcard References

Java allow us to use wildcards in collections when we don’t know what the collection will hold at runtime by doing for example: Set<?> setOfUnknown as opposed to raw types. Supposed you want to create a copy of a collection inside a method, and that collection happens to be using a wildcard, So you might think this is ok:

public List<?> copyList(List<?> list) {
     return new ArrayList<?>(list);
}

This is illegal! However, this is fine:

public List<?> copyList(List<?> list) {
     return new ArrayList<Object>(list);
}

Static Methods of Generic Classes Cannot Reference the Type Parameters of their Enclosing Generic Class

class SomeClass<T> {
     public static void doSomethingWithT(T t) { } //error
}

Exercise
There are still some other sharp edges you would encounter when using Generics, unfortunately we cannot discuss them all. So before I formally end this article, let’s exercise our minds with this little puzzle.

What would be the output of this program?

public class GenericClass<T> {
     public void displayAll(Collection<?> collection) {
          String output = "";
          for(Object o : collection) {
              output += o;
          }
          System.out.println(output);
     }

     public void displayAll(List<Integer> ints) {
          String output = "";
          for(int i : ints) {
              output += i;
          }
          System.out.println(output);
     }

     public static void main(String[] args) {
          List<String> strings = Arrays.asList("1", "2", "3");
          new GenericClass().displayAll(strings);
     }
}

It may seem that this would print “123″ but this would actually throw a ClassCastException at runtime.

Where did the ClassCastException came from?

If you will take a closer look, the methods of class GenericClass declares generic types but the way GenericClass was instantiated inside the main() method, the class was declared without specifying a type for its generic type parameter.

So class GenericClass was instantiated as a raw type. And using raw types Erases ALL generic type information. Remember that, ALL generic type information are erased. So the wildcard “?” in Collection<?> is erased leaving it as a raw Collection, and the Integer type parameter at List<Integer> is erased leaving it also as a raw List.

Now, the call to displayAll(strings) which if we have declared the type for the generic class during instantiation would have called the method displayAll(Collection<?> collection), since the class was instantiated as raw type, and type information are erased from the method, the runtime will look for the most specific overload of displayAll() thus calling displayAll(List<Integer> ints). And inside that method, we looped through ints expecting the Integer to be auto-unboxed to int, but since type is erased, instead of List of integers, ints actually contains Strings, and when an attempt to unbox String to int, a ClassCastException is thrown.

Another problem with this code is that it declares a generic type T, but the generic type is never used inside the class.

Actually if you will pay attention to your compiler, compiling this code will actually give us a warning.

Type safety: The method displayAll(List) belongs to the raw type GenericClass. References to generic type GenericClass should be parameterized.

The warning suggests the the method displayAll() which accepts a List argument would be called.

Summary

• While Generics offer type-safety, we must remember that Java’s Generics feature is implemented at compile-time. At runtime, type information are erased; so don’t expect to use generic types the way you would normally do with non-generic types.
• Dont’ use raw types in new code.
• Generic classes should be instantiated the way they are meant to and never instantiate them as raw types as it erases ALL type information.
• Auto-unboxing happens and hurts when you least expect it.
• Do not ignore compiler warnings.

Reference

• Google I/O Session: Java Puzzlers Presented by Josh Bloch and Jeremy Manson – YouTube Video

There are two types in Java Programming Language. The first is primitive type such as int, double, and boolean. The second is the reference type such as String, List, and Set. Every primitive type has a corresponding reference type, called a boxed primitive. The boxed primitives corresponding to int, double, and boolean are Integer, Double and Boolean.

Java release 1.5 supports automatic conversion of primitive types to their corresponding Boxed primitive types in assignments, and method and constructor invocations. This conversion is known as autoboxing. It also supports automatic unboxing, where Boxed primitive types are automatically converted into their primitive equivalents if needed for assignments, or method or constructor invocations.

These features blur but do not erase the distinction between the primitive and boxed primitive types. It is very important that you are aware of which you are using, and that you choose carefully between them. I will specify some important points that you need to consider to avoid getting into trouble in using these primitive and boxed primitive types.

1. Primitives have only their values, whereas boxed primitives have identities distinct from their values. Consider the code snippet below:

   Integer x1 = 150;
   Integer x2 = 150;
   int a1 = 150;
   int a2 = 150;
   
   System.out.println(x1 == x2);
   System.out.println(a1 == a2);

   This prints false and then true. You may think that this will print true and true. The x1 == x2 uses the Java Identity check, that is if they refer to the same instance on the heap. The second is the value check. One way to fix this is to use the equals method, that is x1.equals(x2).

2. Primitive Boxed types can contain a null value whereas the primitive types cannot. Consider the code snippet below:

   private Boolean valid;
   
   public void foo( ) {
       if (valid) {
           System.out.println("VALID");
       } else {
           System.out.println("INVALID");
       }
   }

   This code may potentially throw a NullPointerException when evaluating (valid). The problem is that valid is a Boolean, not a boolean, and like all object reference fields, its initial value is null. This may go unnoticed for some time as valid may obtain its value from a setter or constructor. When the program evaluates (valid) — which is the same as (valid == true), it is comparing a Boolean to a boolean. When you mix primitives and boxed primitives in a single operation, the boxed primitive is auto-unboxed. If a null object reference is auto-unboxed, you get a NullPointerException.

3. Primitives are more time- and space-efficient than boxed primitives. The code below will compile without error nor warning.

   Long sum = 0L;
   for (long i = 0; i < Integer.MAX_VALUE; i++) {
       sum += i;
   }
   System.out.println(sum);

   However, this is much slower than it should be because it accidentally declares the local variable (sum) as Long instead of the primitive long. The variable is repeatedly boxed and unboxed causing the performance degradation.

4. Be aware of the Byte, Short, Integer and Long Constant Pool. Consider the following code snippet:

   Integer i1 = 100;
   Integer i2 = 100;
   
   Integer j1 = 128;
   Integer j2 = 128;
   
   System.out.println(i1 == i2);
   System.out.println(j1 == j2);

   This will print true and false. You may be wondering and may think that this must print either true and true or for the very least false and false. Where’s the consistency here? The JVM actually maintains pool of values for these data types ranges from -128 to 127. Creating Object using these data types that falls in that range will assign objects from the pool and thus the Java Identity test works — and that’s what happens in (i1 == i2). If you assign value outside of that range, it will create a new different object and thus the Java Identity test fails — and that’s what happens in (j1 == j2).

   On the contrary, using Constructor to create an Object using those types will ignore the pool even if the value falls from -128 to 127. The code below will print false.

   Integer y1 = new Integer(1); //Bad Practice: use Integer.valueOf instead
   Integer y2 = new Integer(1); //Bad Practice: use Integer.valueOf instead
   
   System.out.println(y1 == y2);

5. Be aware of method overloading. This may sounds a separate or unrelated issue but I just want to point out the effect of Boxing (if not carefully used) along with the addition of Generics. The code below adds the integers from -3 through 2 to a sorted set and to a list.

   Set<Integer> set = new TreeSet<Integer>();
   List<Integer> list = new ArrayList<Integer>();
   
   for (int i = -3; i < 3; i++) {
   	set.add(i);
   	list.add(i);
   }
   for (int i = 0; i < 3; i++) {
   	set.remove(i);
   	list.remove(i);
   }
   System.out.println(set + " " + list);

   Most programmer may expect the program to remove the non-negative values (0, 1, 2) from the set and the list, and to print [-3, -2, -1] [-3, -2, -1]. However, the program removes the non-negative values from the set and the odd values from the list, thus printing [-3, -2, -1] [-2, 0, 2]. This may sound confusing. Here’s what’s happening: The call to set.remove(i) selects the overloading remove(E) — where E is an Integer, and autoboxes i from int to Integer. So the program ends up removing the positive values from the set. On the other hand, the call to list.remove(i) selects the overloading remove(int i), which removes the element at the specified position from the list. Thus if you remove the elements at index 0, 1 and 2, you’re left with [-2, 0, 2]. To fix the program, cast list.remove‘s argument to Integer, forcing the correct overloading to be selected.

   Prior to release 1.5, the List interface had a remove(Object) method in place of remove(E), and the corresponding parameter types, Object and int, were “radically different”. Two types are radically different if it is clearly impossible to cast an instance of either type to the other. But in the presence of generics and autoboxing, the two parameter types are no longer radically different. In other words, adding generics and autoboxing to the language damaged the List interface. Always keep this behavior in mind when working with method overloading and primitive and boxed primitive types. To learn more about method overload, please refer to Item 41 (Use Overloading Judiciously) in the Effective Java by Josh Bloch.

As a summary, prefer Primitive types to Boxed Primitives (Item 49). Primitive types are simpler and faster. You should only use Boxed Primitives in situation where you are not permitted to use primitve types such as: (1) as elements, keys and values in collections, (2) as type parameters in parameterized types, and (3) for reflective method invocation.

Reference:
— Effective Java Programming Language Guide (Second Edition) by Joshua Bloch

So, why is there a need to retrieve values using reflection? In our applications, there are two uses of this:

1. Retrieving values for audit logging. In order to keep track of all changes in a record, the application must be able to identify changes in each of the field. To do this, we use reflection to browse through the fields and detect changes.
2. Configurable Setting. Reflection can also be used to allow your application rules to be configurable by the user. For example, a notification facility that is triggered only when user defined criteria is satisfied. Configurable rules is certainly much better than hard-coded rules, it is dynamic and can be configured during runtime by the end-user and not the programmer.

So, here’s the piece of code that allows you to recursively retrieve object values through a standard Java object notation (e.g. employee.name, employee.office.location) that we have used for the features described above:

	public static Object retrieveObjectValue(Object obj, String property) {
		if (property.contains(".")) {
			// we need to recurse down to final object
			String props[] = property.split("\\.");
			try {
				Object ivalue = null;
				if (Map.class.isAssignableFrom(obj.getClass())) {
					Map map = (Map) obj;
					ivalue = map.get(props[0]);
				} else {
					Method method = obj.getClass().getMethod(getGetterMethodName(props[0]));
					ivalue = method.invoke(obj);
				}
				if (ivalue==null)
					return null;
				return retrieveObjectValue(ivalue,property.substring(props[0].length()+1));
			} catch (Exception e) {
				throw new InvalidImplementationException("Failed to retrieve value for "+property, e);
			}
		} else {
			// let's get the object value directly
			try {
				if (Map.class.isAssignableFrom(obj.getClass())) {
					Map map = (Map) obj;
					return map.get(property);
				} else {
					Method method = obj.getClass().getMethod(getGetterMethodName(property));
					return method.invoke(obj);
				}
			} catch (Exception e) {
				throw new InvalidImplementationException("Failed to retrieve value for "+property, e);
			}
		}
	}

Hope this helps!

I’ve been an Agile and Scrum twitter contributor for more than a year already and I have read countless blogs and articles about Scrum and Agile Development. There’s this one Agile article that I really like and I want it to share with you. This article is entitledTen Principles of Agile Tester . Author Lisa Cripin and Janet Gregory wrote the recently published Addison-Wesley bookAgile Testing, a book that fills a much-needed break in agile literature. It is a detailed guidance for testing in an agile environment. However, in this article I picked the important ones based on my experience that helped me do my work better.

1. Provide Constant Feedback — The agile tester is the one who is providing the team with feedback: One of which is providing daily status reports wherein it contains the testing duration, types of tests made, total number of bugs found, total number of bugs fixed, total number of bugs remaining and issues/concern regarding the project. This will help the team to track whether the system is ready for release or not.

2. Have Courage — This is one of the larger challenges of agile is nourishing a swift iterative environment, where every three to four weeks we need to deploy quality software. This certainly demands significant courage. Yet the irony is that we also need to understand that iterations give us opportunities to learn how to fail and adapt something that require an even heavier dose of courage!

3. Keep it Simple — This principle has two significant usage to me. One is that an Agile tester can aid the insistence on overly-elaborate features. Testers can help the customer appreciate and know the necessary features that a system should have. In this way, customers may lessen enhancements which are not needed by the system. Second, tester can help developers understand the features that are needed to be done by providing simple list of bug records. This may help the team in meeting the expected time of deployment (or not).

4. Practice Continuous Improvement — The reason why we are using iteration is to allow learning to take place. Testers should be part of the retrospectives (and if you’re not consistently adapting based on the results of retrospectives, you’re not agile enough). Testers should also consider their career as a profession by continually learning. Technology is fast approaching and it is certain that as the technology goes swiftly, testers should also keep abreast with the latest tool, testing techniques and systems to keep pace on the technology we have right now.

5. Respond to Change — Here in our company, enhancements and change request are not new to us, and as an agile tester and as a person working in an agile environment, we need to cope with the customer changing his or her mind from iteration to iteration, and correspondingly learns how to incrementally flesh out necessary testing specifications.

6. Self-Organize — An agile tester should be organize, especially in releasing bug reports. It must be categorized by priority to determine the bugs that are needed to be fixed a head of time. This will help the team accomplish whatever task they have and meet the deadline.

7. Enjoy — The ability to help drive the process and be a true, equal contributor to a team can be extremely gratifying for an agile tester. Enjoying and embracing what you were doing is one of the biggest factor for a person to stay in a certain organization.

I chose only seven from the list because I find this seven much essential from the other principle that I did not choose namely Deliver value to the customer, Enable face to face communication and Focus on People. If you have all the principles stated but you’re not enjoying what you are doing, well I guess it’s useless. Because being a tester is not just testing a software and giving bug reports, it’s all about enjoying and loving what you’re doing to be successful and feel successful.

Today marks another milestone for Ideyatech as the company officially announces Ideyatech Labs. Ideyatech Labs is the company’s product development and R&D arm aimed towards developing innovative software solutions to real-world problems. This momentous event shows that the company is serious in moving towards developing creative software applications.

“I’m excited that we have finally managed to get into product development. This has always been my dream and my passion,” said Mr. Allan Tan, CEO/President of Ideyatech, Inc. “Ideyatech Labs will be the center of excellence at Ideyatech and will further strengthen our technical knowledge,” he added.

Ideyatech Labs will focus its research on the following areas:

• Artificial Intelligence
• Natural Language Processing
• Collective Intelligence
• Developer Productivity Tools
• Mobile Applications

“No Class is an Island” —Joshua Bloch

Have you encountered having duplicate values in a Set? How about adding an object to a list and then the list’s contains method say that it did not contain that object? How would you solve this? Where do you start tracing?

Have you ever thought that your Class may not implement the equals and hashCode methods? When you override the equals and hashCode methods, have you complied with their general contracts?

General Contract. Yes, when you override the equals method, you must adhere to its general contract as follows.

1. It is reflexive: For any reference value x, x.equals(x) must return true.
2. It is symmetric: For any reference values x and y, x.equals(y) must return true if and only if y.equals(x) return true.
3. It is transitive. For any reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) must return true.
4. It is consistent. For any reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the object is modified.

//acquire session1
Object a = session1.get(Item.class, new Long(1234));
Object b = session1.get(Item.class, new Long(1234));

//close session1
//some code
//acquire session2

Object c = session2.get(Item.class, new Long(1234));
//close session2

Set allObjects = new HashSet();
allObjects.add(a);
allObjects.add(b);
allObjects.add(c);

public boolean equals(Object other){
     if (this == other) return true;
     if (!(other instanceof User)) return false;
     final User that = (User) other;
     return this.getUsername().equals(that.getUsername());
}

public int hashCode(){
     return this.getUsername().hashCode();
}

I remember when my boss told this phrase to me  during my evaluation. Most of the time, my role is a support member to existing projects. And since the project is already done, I just add up a little fragment of code in order to resolve bug reported. And because of that, it’s difficult for me to practice clean coding. However, he told me that I can learn to write clean codes from those existing codes. Identify what are the parts that need to be improved and try to avoid such practices. And also acquire some techniques in enhancing it.

Being involved in a company wherein its vision is to be globally recognized in building creative software applications, demands us to improve our skills. The need to improve our programming skills made me stumble upon this book entitled “Clean Code: A Handbook of Agile Software Craftsmanship” by Robert C. Martin.

Here are some of the concepts that I am able to relate in my career as a programmer:

Method/Function — Have you already experienced wandering around a method that consist of hundreds of lines. Methods that contain a lot of abstractions and too many things going on and you’re trying to understand what these complex codes do until your eyes starts to get teary because of prolong staring? In addition to this, confusing names are also used, which makes you even more stirred up. Programmers should avoid using these names and start to practice using a more meaningful names. In  projects we accomplished, every method has a name which describes parameters that the method accepts and also the main procedure it does. An example of this is the method loadByUserName(String userName). At one glance , you already have an idea that this method accept a parameter username that will be use to retrieve a particular user. This demonstrates the usefulness of this principle.

Comments — Comments are usually taken for granted. Programmers easily neglect the importance of a comment until it’s needed. For example, I normally see a comment in the beginning of the code that tells you a little description of the codes, who is/are the author/s and other details of the codes.Even so, as I continue to program, I often forgot to place my name in that particular comment section. And because of that, whenever someone needs to clarify something regarding the code, he/she do not have an idea who to consult with. Therefore, the coder was left no choice but to study it, and if he can’t , just rely to guess.Sometimes, that minimal negligence leads to a more serious problem. Taking responsibility is an important part of being a professional.

Formatting — Is this necessary? My answer is yes. Why? Based from experience, it’s such a pleasant thing to see that your code is arranged properly. Brackets are well-aligned. Conditionals are placed in such a way that you can easily identify their scope the same with the declaration of variables. These little things would help  programmers a lot in their coding. One advantage of this is that they are readable. You can easily pin point codes that are related. And from that, you can now  understand the codes without difficulty and can work on it right away.

Handling Errors — Lately, I realized that this specific concept is very important to me as a programmer. Knowing what the particular error is, will provide you a clearer way to formulate a solution to that problem. I believe that there’s no such thing as a perfect code because for me, bugs are inevitable. The only thing that we could do is to handle them properly. Try to generate a step that you can deduce a specific one from a more general one. And from there, you can now proceed in debugging and resolving the problem.

These principles are often forgotten and ignored. Even so, these simple ideas are as important just like any other components in programming. So next time that you’ll be doing some programming again, always keep these tips in mind and continue to practice writing clean codes as it will make you a better and happier developer.

Back in 1999, Tim Berners Lee expressed his vision about the semantic web:
I have a dream for the Web [in which computers] become capable of analyzing all the data on the Web – the content, links, and transactions between people and computers. A ‘Semantic Web’, which should make this possible, has yet to emerge, but when it does, the day-to-day mechanisms of trade, bureaucracy and our daily lives will be handled by machines talking to machines. The ‘intelligent agents’ people have touted for ages will finally materialize.

The word semantic stands for the meaning of , and semantic web is a web that is able to describe things for computer to understand. In semantic web, the web is not just about links, it is also about the relationships between things, and the properties of things.

Since the time the semantic web has been envisioned, there had been so many efforts to put this into reality such as the use of RDF (Resource Description Framework) and some also had the wrong impression that their website is semantic just by describing a bunch of <div> and other elements with the use of IDs and classes .

With the introduction of HTML5 , it would be easier for us to create semantic web pages because of its new structural and content tags.

HTML5 NEW STRUCTURAL TAGS

1. <section></section> – generic section of a document or application. Thematic grouping of content with a heading.
2. <article></article> – represents a self-contained composition in a document, page, application or site that is independently distributable or reusable such as in syndication. (E.g, forum post, blog entry, user comment)
3. <aside></aside> – represents a section of a page that consists of content that is tangentially related to the content around the aside element and which could be considered separate from the content
4. <header></header> – represents a group of introductory or navigational aids, This is intended to contain section’s heading (h1-h6 or an hgroup element), but not required. This can also be used to wrap section’s table of contents, search form or logos.
5. <hgroup></hgroup> – used to group a set of h1-h6 elements when the heading has multiple levels such as subheadings, alternative titles or tag lines.
6. <footer></footer> – represents a footer for its nearest ancestor sectioning content or sectioning root element. This can be used to contain information about the section such as author, links related to it, or copy right data. A document may contain multiple footers. Footer is not just limited to the whole document but can also be used for sections.
7. <nav></nav> – represents section of a page that links to other pages or to parts within the page.

HTML5 NEW CONTENT TAGS

1. <figure></figure> – represents some flow content optionally with a caption. Can be used to annotate illustrations, diagrams, photos, code listings etc.
2. <video></video> – media element whose data is video data possibly with associated audio data
3. <audio></audio>
4. <canvas></canvas> – providing scripts with a resolution dependent bitmap canvas which can be used for rendering graphs, game graphics, or other visual images on the fly.

OUTLINE ALGORITHM

HTML5 has a new algorithm that instructs user agents how to parse HTML documents. The outline algorithm tells user agents how to parse sectioning contents within a document. Understanding the outline algorithm will ensure you that your documents would be parsed the way you want it to be. This could be used from a semantic standpoint for accessibility reasons or to make your content easier to syndicate.

One of the way to imagine the outline algorithm is to think of your content as a table of contents.

• Site Title
  • Section 1
    • Article 1
    • Article 2
  • Section 2
    • Article 1

Outline Algorithm Parsing

• Section and Heading contents are used to define the outline
• Body is established as the outline root
• Items are added to the outline as sectioning content is found
• Heading contents are used to name sections
• Sectioning content within another sectioning content is nested in the outline

Example HTML5 Code:

<body>
<heading>Ideyatech Inc. - Java Outsourcing Philippines</heading>
<section>
<h1>Products and Services</h1>
<article>
<h1>Our Services</h1>
<p>Content....</p>
</article>
<article>
<h1>Our Products</h1>
<p>Content...</p>
</article>
</section>
</body>

The outline algorithm would generate this outline based on the above code:

• Ideyatech Inc. – Java Outsourcing Philippines
  • Products and Services
    • Our Services
    • Our Products

As you can see, with HTML5, we can easily create semantic web pages not just on a markup viewpoint but also on making proper document structure by understanding HTML5′s document outline algorithm.

HTML5 would also impact SEO and SEM as more and more websites start using HTML5, and the more user agents start supporting it, new SEO and SEM strategies may emerge targeted towards HTML5. The way search engines crawl web pages may also be changed in support of HTML5.

Though HTML5 is still in its infancy, it has already gained so much attention as companies like Apple and Google started using it and the W3C also announced that it expects HTML5 to reach recommendation status by 2014.

With all these efforts going around HTML5, you may want to start exploring HTML5. Who knows, maybe in the next 2 to 3 years, HTML5 would be the new standard.

Natural Language Processing is a branch of Artificial Intelligence that is focused on understanding the human language. Several useful applications have been recently released that uses NLP technology such as Google Translate, Ask.com and others.

“We believe we can learn a lot by working with the academe. Their research efforts are critical towards developing cutting-edge technologies.” as described by Allan Tan, CEO and President of Ideyatech.

Some of the interesting topics include:

• Information extraction
• Machine translation
• Question answering
• Creative text analysis and generation
• Word sense disambiguation, semantic role labeling and semantic parsing
• Machine learning for natural language

During the symposium, the group also elected the first batch of NLP Special Interest Group (NLP SIG) officers in an effort to build a community of NLP research enthusiasts. The group unanimously voted De La Salle University Dean, Dr. Rachel Roxas as President while Ideyatech CEO, Allan Tan was voted as the Treasurer.

For more information, visit http://st.dlsu.edu.ph/nnlprs/

Instead of celebrating it the usual way, we decided to do it differently this time. As a way of celebrating our anniversary, the company decided to share the blessings we had and connect to those who are in need. Last November 5, 2010, the Company set forth to Calauan, Laguna to lend a hand to Habitat For Humanity Int’l, a non-profit ecumenical Christian housing organization in one of its projects.

Habitat in cooperation with ABS-CBN Foundation revived a housing project in Calauan which was started by the former President Joseph Estrada almost 10 years ago. The project would serve as relocation for those families living along the banks of Pasig River. After years of inactivity, the project was revived for good and we’re glad to be part of the effort.

We arrived at the site around 10:00am and immediately started working after the short orientation. We helped them pile blocks for walls, build hollow blocks from scratch, and plastering of walls.

It’s a wonderful feeling doing these stuff which most of us are not quite used to. We get to appreciate the efforts these people are exerting in order to build homes for their fellowmen. We get to experience their work, shed sweat the same way and feel the pain we may never have felt before. In the end we realized, its worth the pain and effort as long as its for the betterment of our fellowmen.

With this event, we may have changed our definition of celebration, from the normal notion of “feast” to a more profound “sharing and lending hand”.

The Habitat for Humanity outreach is indeed a kick-ass way to celebrate our anniversary.

Check out some of the candid moments:

Life after college, coming from a school where education is traditionally taught, is undeniably different. I used to think that working would nonetheless be just like how my teachers/professors teach me what to do. Though I have not been disappointed to learn much from the people I’ve been working with so far, a famous saying applies, “The more you know, the more you know not”.

Technology is so fast-paced that Computer Science, IT, and other technology related courses like mine need not to go through board exams. The industry has so much to offer – I can actually say that there seems to be an overflow in information. Therefore, I cannot know enough, progression is essential.

Demands of work are high. I needed not only to adapt to the changes in my environment, but as well as to the culture of technology.  And amidst all the pressures, similar to my co-workers, have time for learning to hone my craft. Surprisingly, to formally impose an informal invitation to learning, Ideyatech introduces T3, something that seemed to me as school reporting. What more can I say? Reality itself is a school.

T3 stands for Tuesday Tech Talk. It is conducted every other Tuesday, and is where we are encouraged to become a speaker. Through a draw lots, schedules are set. Speaker shall discuss a preferred topic related and relevant to the industry (I think it’s an advantage if it’s beneficial the project we’re currently into). A minimum of 15 minutes will do, as long as the essentials are tackled well.

I personally take this as a reminder not to cease learning, so I am geared with the knowledge significant to keep up with the current trends in IT.

I have yet to experience my T3, but on my observation and evaluation, I listed some of the benefits of participating in such an activity, which I’ve been looking forward to get hold of:

1. It induces continuous learning. Getting into IT usually needs an area of specialization. With T3, we get the chance to share our areas of specialization with each other. Not only is it beneficial to the audience’s learning but as well to the speaker, as teachers say, “you also learn from your students”, maybe through a mini-discussion or brainstorming during the talk.

Aside from a specialization, I personally aim to check out what are the things not on my cup of tea that’s worth giving a try. Discover and explore a software, methodology, or theory. Who knows, together with my co-workers, we can devise something better.

2. It motivates innovation. Not because the company, as a whole, makes good results in whatever applications, methodologies it implements, should we stop there. Maybe right now we’re in, and tomorrow we can be not. With this said we are motivated to strive and find alternative solutions to further uplift the quality of our services and have the edge over our competitors.

On the sidelines, perk up the presentation. Re-invent on how to make every discussion fun and worth listening to, also challenges our innovation.

3. Improves confidence. Thinking how much time I spend at home, resting, and spending time with my family with how much time I spend at work. I realized, majority of the time I am actually keying the keyboard, clicking the mouse buttons, and burning the hours facing my computer monitor.

T3 allows a talk time to let us speak out our minds once in a while. Not only does it develop public speaking for the shy types, but as well let the good speakers among us exercise their skill. Nonetheless, we all need this when interacting, especially with the clients, our boss, and co-workers.

And did I forget that for juniors like me, have the guts to for once, pretend to know more over your seniors. And to keep the confidence up, should I remind myself that they cannot know everything, I just need to be prepared for an inquest in case they know the topic more than I do, or plain interested.

4. Practice pressure handling Answering queries from seniors is one heavy pressure. Add it up to the demands of work, deadlines and all and sum it up to the best pressure handling improvement session.

No to forget that it too is an instant bonding activity – merienda party, for there’s free food we can dig in during or after every talk. Plus, it’s a thought-I’d-only-find-it-in-school activity that although a conventional way of learning/teaching, opens our eyes to the modern developments of our time.

Last month, I did the performance appraisal of Ellaine, a trainee hired fresh from college 6 months ago. Ellaine graduated from a prestigious, traditional, all-girls school run by Nuns who values academic excellence, moral values and religious teachings.

During the performance appraisal discussion,

Me: Ellaine, I want you to be more pro-active. I want you to take your own initiative and not wait for detailed instructions.

She looked a bit confused…

Me: Remember when I asked you to prepare the templates last week? You should have not waited for me to get it from you. Just email it to me the moment you are done.

She nodded but still with confusion. So, I told a couple more examples and explain how to be more pro-active.

Me: And do not be afraid to make mistakes.

She looked confused again…

Me: Remember when you made that mistake (cite example). I didn’t get mad afterwards, I just hope that you have learned your lessons and avoid doing the same mistakes again.

Still the same confusion… and I tried expounding more on my point.

Me: So, what other goals do you like to accomplish in the next 6 months.

Ellaine: I would like to do everything that was taught to us during the “Software Testing Training”. Currently, we’re only doing about 20% of what we’re taught.

Now, I’m the one confused…

Me: Well, you probably don’t have to do everything that was taught. Just pick the essential ones that are needed to ensure a high quality software.

I suddenly realized what is happening.

Ellaine being fresh from college is trained from traditional education. She is trained to memorize facts and formulas, trained to write down everything on the board, trained to recite, trained to obey rules, and trained to get punished for misbehaving.

So, I told her about the qualities needed to be more agile as opposed to what is taught in traditional education.

Me: You’ll need to break free from what the school has taught you for the past 16 years. At work, you need to understand what you are doing and more importantly, why you are doing them. You do not just follow instructions, you have to analyze and question them.

Ellaine (with a smile): Remember, when we have to file for 3 days leave to attend to our graduation practice. You suggested us not to attend because it is a complete waste of time, but still we attended and filed that leave… It is because we have been trained to obey. You are right, it is a complete waste of time, but it didn’t matter as long as we obey the rules.

Me: Well, you are no longer in school. From now on, I want you to think on your own. You are aware of our project goals, and you are responsible to achieve those goals.

We ended up our evaluation review, with a positive note: “Break that tradition!”

Unfortunately, many of the schools teach in a very traditional fashion where rules are unilaterally set by the teachers and everyone is expected to obey the rules. This is the root of anti-agile. This is why many companies struggle implementing Agile and why project managers are more effective than scrum masters. The team is trained on an educational system for 2 decades that is anti-agile and breaking that tradition is not easy.

Nevertheless, recognizing that the roots of anti-agile is due to the traditional education system is a good place to start. By simply acknowledging that work life is totally different than school life,  applying agile practices will be much simpler.

]]> http://www.ideyatech.com/2010/10/the-roots-of-anti-agile/feed/ 2 http://www.ideyatech.com/2010/10/company-bonding-over-mooncake-dice-games/ http://www.ideyatech.com/2010/10/company-bonding-over-mooncake-dice-games/#comments Tue, 05 Oct 2010 02:50:39 +0000 Kervi Cioco http://www.ideyatech.com/?p=273 Two years ago, the company had its first mooncake games as a form of company bonding to celebrate the Chinese Mooncake Festival. Everyone had a blast last time around, so this year we had the exact same activity with a lot of new faces to introduce to and way bigger prizes!]]> Two years ago, the company had its first mooncake games as a form of company bonding to celebrate the Chinese Mooncake Festival. Everyone had a blast last time around, so this year we had the exact same activity with a lot of new faces to introduce to and way bigger prizes!

Here are some candid moments from that fun-filled night:

AND THE BIG WINNERS!!

First Prize: Borgy — who won an X-mini II. Second Prize: Julius & Rosel — who each won a Smart Bro Prepaid Kit.

“Definition of Done” is a common term used in agile development. It is a simple phrase, yet very powerful. Many of us ignore this, until we understand and realize that it is happening all around us.

What is your definition of done?

If a module has been analyzed, programmed to specifications, is it considered done? How about testing? integration? documentation? acceptance testing? When do you say something is actually “done”?

Is your definition of done the same with the rest of your team members? Here’s one story that is common in an IT workplace:

PM: Hello, are you done with your module?
DEV: Yes
PM: Great! let’s deploy it today.
DEV: What?!? But it hasn’t been tested yet?
>> Both are now confused. <<

There are two (2) important lessons I’d like to share from this simple concept.

(1) Ensure everyone in your team has the same “definition of done”. This ensures that everyone understands the team status. If necessary, create a checklist as a guide for everyone.

(2) Extend your “definition of done”. Many programmers define “done” as completing the codes based on the specifications. Try extending their definition by adding items (e.g. javadoc, unit tests) on every iteration. Not only you improve software quality, but you also improve developer skills and discipline.

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

But how can you ensure that:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

A few more things to note:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

STEP #1: Install lib-virt package.

sudo apt-get install kvm libvirt-bin

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

sudo adduser $USER libvirtd

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

STEP #3: Install bridge utilities.

sudo apt-get install bridge-utils

STEP #4: Configure network to bridge setup.

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

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

STEP #5: Restart networking service.

sudo /etc/init.d/networking restart

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

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

sudo apt-get install virt-manager

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

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

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

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

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

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

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

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

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

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

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

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

• OOP (of course)

• Creating graphical user interfaces (GUI)

• Using the Java API

• Exception handling

• Sorting data structures

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

• Creating network applications (create a chat client)

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

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

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

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

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

• support for both structured and unstructured content

• hierarchical design

• SQL and/or XPath query

• access control

• locking

• full-text search

• versioning

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

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

Apache Jackrabbit

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

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

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

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

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

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

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

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

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

Here’s what we’re trying to produce.

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

I. Producing the Rounded Corner Images

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

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

II. The HTML Code

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

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

III. The CSS Code

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

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

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

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

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

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

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.

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

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.

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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/