Vervesys Blog, Software application development, Verve Blog

Too many terms are being used and are confusing the decision makers thus making them reluctant to trust outsourcing. It’s good to outsource but at the same time it’s important to understand what these terms mean with or without relating to outsourcing.

Outsourcing means out-sourcing, i.e. giving a part of the organizational activity to another company, organization, or even sub-organization (a department within the organization) with mutual interest, so as to concentrate on core organizational activity (in which the organization has expertise) than working on auxiliary activities.

Onsite means the site where the activity is performed, for instance, “onsite” for a banking software is the back office where that software is actually being (or is being deployed for use).

Onshore means the same shore where the activity is performed. Same shore usually refers to the same continent.

Offsite means away from the site of activity.

Offshore means away from the shore of activity and not only site, so, offsite can either be onshore or offshore.

With endurance and experience, Verve Systems has evolved with appropriate combinations of onsite, onshore, offsite and offshore mechanisms to add optimum value to the outsourced activity in various industries and size of businesses.

Verve Systems has realised the importance of being onsite for crucial activities to minimize hassles and operating from offshore for man power dependent activities to maximize savings; and has helped its clients to ensure well managed execution of outsourced activities and significant savings thus leading to quantitative as well as qualitative results of outsourcing.

With growing competition in outsourcing, outsourcers are getting more and more aggressive in selling their services than ever. This aggression is becoming a reason for a lot of distrust within the industry.

To overcome this distrust, the concept of Activity Partnership is emerging like anything. A company, with a need for software development activity will partner with a similar scale or lower scale software development company to become their software development partners instead of following conventional outsourcing mechanism. This model like any other model brings a few challenges along, which, if not addressed may lead to bitter relations between partners. These challenges include:
1) Retaining the trust: Either of partners when tries to leverage the trust, it may result into the other partner realizing it and feeling cheated in the relationship
2) Consistent Quality: As the engagement goes on, supplier is bound to feel relaxed in maintaining the relation resulting into lesser drive and commitment hence lesser quality of delivery
3) Fear of losing business: When the client asks for a work which is not a part of supplier’s offering, supplier usually tends to say yes due to fear of losing the engagement, which may result into failure of projects.

Sense of ownership, shared benefits of success and responsibility for failure are the only ways (all together) of sustaining such engagements. In short we can call it absolute transparency. Well, but this is about sustenance, and should be kept in mind while choosing a partner. Still in the inception phase, things that matter the most are:
1) Processes
2) Capacity / Scalability
3) Capability (Skillset and experience and exposure)
4) Appropriate quality (Product / service need not be perfect, but acceptable)
5) Cost effectivity and Value Addition
Verve Systems, with their approach of “appropriateness than perfection” has ensured that such partnerships (especially offshore product development) are sustainable, value adding, and transparent, thus enabling their partners to trust them consistently and concentrate on their core activities than worrying about offshore relations.

Junit is a Java framework for performing unit tests on code. By testing code after every change, programmers can be reassured that changing a small amount of code does not break the larger system. Without automated testing tools like JUnit, retesting can be a tedious and inaccurate process. By allowing the testing process to occur frequently and automatically, you can keep software coding errors at a minimum.
• Creating test cases :
Test cases for JUnit are written as Java classes that extend the JUnit framework. These classes have a number of methods, each of which tests a particular function, or unit, of the code. Creating a new test case is easy.Writing a new test case requires creating a new Java class.
This class is called the PropertyManagerTest?.java, and it’s where you write your tests. Each time a test is called, JUnit will execute the setUp() method for you to initialize any values you need. Next, it will call a test case and then call tearDown() to undo the initialization and go on to the next test.
• Example
•
package com.sample;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class PropertyManagerTest {
PropertyManager pm=null;
public static void setUpBeforeClass() throws Exception {
}
public static void tearDownAfterClass() throws Exception {
}
public void setUp() throws Exception {
pm=new PropertyManager();
}
public void tearDown() throws Exception {
pm=null;
}
@Test
public final void testLoadProperties() {
try{
assertNotNull(“Unable to load Properties from External File”,pm.loadProperties());
assertTrue(“No properties from external file”,pm.loadProperties().size()>0);
}catch(Exception e){
fail(“Property File is not available or cannot be created”);
}
}
@Test
public final void testGetProperty() {
String propertyKey=”dashboard.targetenvironment”;
String propertyValue=”ec2″;
try{
assertNotNull(“Unable to load Properties from External File”,pm.loadProperties());
assertTrue(“No properties from external file”,pm.loadProperties().size()>0);
assertNotSame(“Given Property is not Available in properties file”,”",pm.getProperty(propertyKey));
assertEquals(“Improper Property Value”,propertyValue,pm.getProperty(propertyKey));
}catch(Exception e){
fail(“Property File is not available or cannot be created”);
}
}
}
}
The above class contains two tests :
• testLoadProperties()
1) Check the properties available or not in property file.
• testGetProperty()
1) Check the properties available or not in property file.
2) Check the given input property against property in property file.
3) Check the given input property value against property value in property file.

From Very Small Companies to Large Enterprises, all of us struggle to explore right usage of technology to support business than to demand huge investments.
A lot of companies spend huge amounts every year for their IT portfolios and software application development to increase automation hence efficiency and reduce efforts in their business. More than 40% of these investments actually remain expenses without yielding any results. And the reasons are:
• Lack of planning (not only financial but also operational)
• Time to market the solutions
• Unmanageable expectations from the solutions
• Subcontracting hassles for larger systems (One supplier’s capacity is not enough to cater to the need)
• Procrastination in investment decisions
• Highly dependent decision making and so on…
Verve Systems has understood the importance of understanding and keeping in mind that technology is to be utilized and not overused for functionality. Verve’s approach is to work upon the Cost vs. Usability trade-off. These problems can be solved by following initiatives and changes in approach:
• Plan holistically than only functionally or financially
• Understand that better solution will always need customization and hence time, so plan time to market accordingly. Also, weightage should be given to choose appropriate packaged solutions as per need
• Have reasonable expectations from the solution and manage the same for stakeholder and users
• Subcontracting will always cause gaps, so it’s crucial to add value at every level of engagement to eliminate these gaps
• Decisions should be made on time and on the other hand, such matters should be identified well in advance and forwarded to relevant authorities well in time to ensure timely decisions
• Dependencies can be reduced to a large extent using appropriate SDLC models, proper planning and timely measurements of progress
Above all these, the approach should be to choose right technology after finalizing the need and budget than to work upon the need and budget based on technology.

For any queries please contact verve@vervesys.com